More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 1,195 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Approve | 20573449 | 110 days ago | IN | 0 ETH | 0.00003304 | ||||
Approve | 20525234 | 117 days ago | IN | 0 ETH | 0.00004832 | ||||
Approve | 19970778 | 195 days ago | IN | 0 ETH | 0.0006741 | ||||
Transfer | 19692238 | 234 days ago | IN | 0 ETH | 0.00071887 | ||||
Approve | 19088559 | 318 days ago | IN | 0 ETH | 0.0008738 | ||||
Approve | 18855390 | 351 days ago | IN | 0 ETH | 0.00106489 | ||||
Approve | 18802565 | 358 days ago | IN | 0 ETH | 0.0008574 | ||||
Approve | 18080490 | 459 days ago | IN | 0 ETH | 0.00064262 | ||||
Approve | 17526826 | 537 days ago | IN | 0 ETH | 0.00063822 | ||||
Approve | 17009575 | 610 days ago | IN | 0 ETH | 0.00051327 | ||||
Approve | 16941359 | 620 days ago | IN | 0 ETH | 0.0008066 | ||||
Approve | 16749498 | 647 days ago | IN | 0 ETH | 0.00202144 | ||||
Approve | 15788224 | 781 days ago | IN | 0 ETH | 0.00047601 | ||||
Approve | 15470224 | 827 days ago | IN | 0 ETH | 0.00023194 | ||||
Approve | 15387772 | 840 days ago | IN | 0 ETH | 0.00033557 | ||||
Transfer | 15382481 | 841 days ago | IN | 0 ETH | 0.0002157 | ||||
Approve | 15267062 | 859 days ago | IN | 0 ETH | 0.00049041 | ||||
Approve | 14450040 | 991 days ago | IN | 0 ETH | 0.00563402 | ||||
Approve | 14076041 | 1049 days ago | IN | 0 ETH | 0.00822981 | ||||
Approve | 13734832 | 1102 days ago | IN | 0 ETH | 0.00704947 | ||||
Approve | 13515146 | 1136 days ago | IN | 0 ETH | 0.00751061 | ||||
Approve | 13440071 | 1148 days ago | IN | 0 ETH | 0.00294872 | ||||
Approve | 13313508 | 1168 days ago | IN | 0 ETH | 0.00384474 | ||||
Approve | 13244298 | 1179 days ago | IN | 0 ETH | 0.00635664 | ||||
Approve | 13239735 | 1179 days ago | IN | 0 ETH | 0.00240238 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
Momentum
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity Multiple files format)Audit Report
// SPDX-License-Identifier: MIT pragma solidity >=0.6.12; import "./ERC20.sol"; import "./Ownable.sol"; import { ABDKMath64x64 as Math } from "./ABDKMath64x64.sol"; contract Momentum is ERC20, Ownable { int128 shortMomentum; int128 longMomentum; int128 SMweight; int128 LMweightEx; int128 LMweightCo; mapping (address => mapping (address => uint256)) _allowances; bool isBurning = false; constructor( uint256 initialSupply, uint256 _shortMomentumWeight, uint256 _LMweightEx, uint256 _LMweightCo, uint256 factor, uint256 _shortMomentum, uint256 _longMomentum ) public ERC20("Momentum", "XMM") { _setupDecimals(10); _mint(_msgSender(), initialSupply); SMweight = Math.divu(_shortMomentumWeight, factor); LMweightEx = Math.divu(_LMweightEx, factor); LMweightCo = Math.divu(_LMweightCo, factor); shortMomentum = Math.fromUInt(_shortMomentum); longMomentum = Math.fromUInt(_longMomentum); } function getShortMomentum() external view returns (uint256) { return Math.mulu(shortMomentum, 1); } function getLongMomentum() external view returns (uint256) { return Math.mulu(longMomentum, 1); } function getMomentumAndSupply() external view returns (uint256, uint256, uint256) { uint256 SM = Math.mulu(shortMomentum, 1); uint256 LM = Math.mulu(longMomentum, 1); return (SM, LM, totalSupply()); } function getNewMomentum(int128 amount, int128 SMcopy, int128 LMcopy) internal view returns (int128, int128) { int128 LMweight = (amount < SMcopy) ? LMweightCo : LMweightEx; int128 LMnew = Math.add(LMcopy, Math.div(Math.sub(amount, LMcopy), LMweight)); int128 SMnew = Math.add(SMcopy, Math.div(Math.sub(amount, SMcopy), SMweight)); return (LMnew, SMnew); } function getRangeData(int128 LMcopy, int128 SMcopy, int128 LMnew, int128 SMnew) internal pure returns (int128, int128) { int128 range = Math.abs(Math.sub(LMcopy, SMcopy)); int128 newRange = Math.abs(Math.sub(LMnew, SMnew)); int128 rangeDelta = Math.sub(newRange, range); return (rangeDelta, newRange); } function getDestabilizingTransferFee(int128 amount, int128 newRange, int128 newLongMomentum) internal pure returns (int128) { // If newRange is within 2% of newLongMomentum, apply ~0.75% fee // to avoid potential overflow calculations and negative log values if (newRange <= Math.div(newLongMomentum, Math.fromUInt(50))) { return Math.mul(amount, Math.div(Math.fromUInt(1), Math.fromUInt(133))); } else { int128 proportion = Math.div(newRange, newLongMomentum); int128 rate = Math.add(Math.fromUInt(1), Math.ln(Math.mul(proportion, Math.fromUInt(50)))); return Math.mul(amount, Math.div(rate, Math.fromUInt(133))); } } function getTransferFee(uint256 amount256, int128 SMcopy, int128 LMcopy) internal returns (uint256) { int128 amount = Math.fromUInt(amount256); // Guard against flood of small transfers manipulating momentum values // If transfer size is less than ~0.3% of lower momentum value, charge 5% fee and skip momentum update if (SMcopy <= LMcopy) { if (amount < Math.div(SMcopy, Math.fromUInt(333))) { return Math.mulu(Math.div(amount, Math.fromUInt(20)), 1); } } else { if (amount < Math.div(LMcopy, Math.fromUInt(333))) { return Math.mulu(Math.div(amount, Math.fromUInt(20)), 1); } } (int128 newLongMomentum, int128 newShortMomentum) = getNewMomentum(amount, SMcopy, LMcopy); (int128 rangeDelta, int128 newRange) = getRangeData(LMcopy, SMcopy, newLongMomentum, newShortMomentum); int128 transferFee; if (rangeDelta < Math.fromUInt(0)) { transferFee = Math.div(amount, Math.fromUInt(133)); // stabilizing transfer ~0.75% fee } else { transferFee = getDestabilizingTransferFee(amount, newRange, newLongMomentum); } longMomentum = newLongMomentum; shortMomentum = newShortMomentum; return Math.mulu(transferFee, 1); } function startBurning() public onlyOwner { isBurning = true; renounceOwnership(); } function burnAndTransfer(address sender, address recipient, uint256 amount256) internal { if (isBurning) { uint256 transferFee = getTransferFee(amount256, shortMomentum, longMomentum); uint256 adjustedAmount = amount256.sub(transferFee); _burn(sender, transferFee); _transfer(sender, recipient, adjustedAmount); } else { _transfer(sender, recipient, amount256); } } function transfer(address recipient, uint256 amount256) public override returns (bool) { burnAndTransfer(_msgSender(), recipient, amount256); return true; } function transferFrom(address sender, address recipient, uint256 amount256) public override returns (bool) { burnAndTransfer(sender, recipient, amount256); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount256, "ERC20: transfer amount exceeds allowance")); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function increaseAllowance(address spender, uint256 addedValue) public override returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public override returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _approve(address owner, address spender, uint256 amount) internal override { 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); } }
/* * ABDK Math 64.64 Smart Contract Library. Copyright © 2019 by ABDK Consulting. * Author: Mikhail Vladimirov <[email protected]> */ pragma solidity ^0.5.0 || ^0.6.0; /** * Smart contract library of mathematical functions operating with signed * 64.64-bit fixed point numbers. Signed 64.64-bit fixed point number is * basically a simple fraction whose numerator is signed 128-bit integer and * denominator is 2^64. As long as denominator is always the same, there is no * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are * represented by int128 type holding only the numerator. */ library ABDKMath64x64 { /** * Minimum value signed 64.64-bit fixed point number may have. */ int128 private constant MIN_64x64 = -0x80000000000000000000000000000000; /** * Maximum value signed 64.64-bit fixed point number may have. */ int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; /** * Convert signed 256-bit integer number into signed 64.64-bit fixed point * number. Revert on overflow. * * @param x signed 256-bit integer number * @return signed 64.64-bit fixed point number */ function fromInt (int256 x) internal pure returns (int128) { require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF); return int128 (x << 64); } /** * Convert signed 64.64 fixed point number into signed 64-bit integer number * rounding down. * * @param x signed 64.64-bit fixed point number * @return signed 64-bit integer number */ function toInt (int128 x) internal pure returns (int64) { return int64 (x >> 64); } /** * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point * number. Revert on overflow. * * @param x unsigned 256-bit integer number * @return signed 64.64-bit fixed point number */ function fromUInt (uint256 x) internal pure returns (int128) { require (x <= 0x7FFFFFFFFFFFFFFF); return int128 (x << 64); } /** * Convert signed 64.64 fixed point number into unsigned 64-bit integer * number rounding down. Revert on underflow. * * @param x signed 64.64-bit fixed point number * @return unsigned 64-bit integer number */ function toUInt (int128 x) internal pure returns (uint64) { require (x >= 0); return uint64 (x >> 64); } /** * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point * number rounding down. Revert on overflow. * * @param x signed 128.128-bin fixed point number * @return signed 64.64-bit fixed point number */ function from128x128 (int256 x) internal pure returns (int128) { int256 result = x >> 64; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Convert signed 64.64 fixed point number into signed 128.128 fixed point * number. * * @param x signed 64.64-bit fixed point number * @return signed 128.128 fixed point number */ function to128x128 (int128 x) internal pure returns (int256) { return int256 (x) << 64; } /** * Calculate x + y. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function add (int128 x, int128 y) internal pure returns (int128) { int256 result = int256(x) + y; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate x - y. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function sub (int128 x, int128 y) internal pure returns (int128) { int256 result = int256(x) - y; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate x * y rounding down. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function mul (int128 x, int128 y) internal pure returns (int128) { int256 result = int256(x) * y >> 64; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point * number and y is signed 256-bit integer number. Revert on overflow. * * @param x signed 64.64 fixed point number * @param y signed 256-bit integer number * @return signed 256-bit integer number */ function muli (int128 x, int256 y) internal pure returns (int256) { if (x == MIN_64x64) { require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF && y <= 0x1000000000000000000000000000000000000000000000000); return -y << 63; } else { bool negativeResult = false; if (x < 0) { x = -x; negativeResult = true; } if (y < 0) { y = -y; // We rely on overflow behavior here negativeResult = !negativeResult; } uint256 absoluteResult = mulu (x, uint256 (y)); if (negativeResult) { require (absoluteResult <= 0x8000000000000000000000000000000000000000000000000000000000000000); return -int256 (absoluteResult); // We rely on overflow behavior here } else { require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); return int256 (absoluteResult); } } } /** * Calculate x * y rounding down, where x is signed 64.64 fixed point number * and y is unsigned 256-bit integer number. Revert on overflow. * * @param x signed 64.64 fixed point number * @param y unsigned 256-bit integer number * @return unsigned 256-bit integer number */ function mulu (int128 x, uint256 y) internal pure returns (uint256) { if (y == 0) return 0; require (x >= 0); uint256 lo = (uint256 (x) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64; uint256 hi = uint256 (x) * (y >> 128); require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); hi <<= 64; require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo); return hi + lo; } /** * Calculate x / y rounding towards zero. Revert on overflow or when y is * zero. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function div (int128 x, int128 y) internal pure returns (int128) { require (y != 0); int256 result = (int256 (x) << 64) / y; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate x / y rounding towards zero, where x and y are signed 256-bit * integer numbers. Revert on overflow or when y is zero. * * @param x signed 256-bit integer number * @param y signed 256-bit integer number * @return signed 64.64-bit fixed point number */ function divi (int256 x, int256 y) internal pure returns (int128) { require (y != 0); bool negativeResult = false; if (x < 0) { x = -x; // We rely on overflow behavior here negativeResult = true; } if (y < 0) { y = -y; // We rely on overflow behavior here negativeResult = !negativeResult; } uint128 absoluteResult = divuu (uint256 (x), uint256 (y)); if (negativeResult) { require (absoluteResult <= 0x80000000000000000000000000000000); return -int128 (absoluteResult); // We rely on overflow behavior here } else { require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); return int128 (absoluteResult); // We rely on overflow behavior here } } /** * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit * integer numbers. Revert on overflow or when y is zero. * * @param x unsigned 256-bit integer number * @param y unsigned 256-bit integer number * @return signed 64.64-bit fixed point number */ function divu (uint256 x, uint256 y) internal pure returns (int128) { require (y != 0); uint128 result = divuu (x, y); require (result <= uint128 (MAX_64x64)); return int128 (result); } /** * Calculate -x. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function neg (int128 x) internal pure returns (int128) { require (x != MIN_64x64); return -x; } /** * Calculate |x|. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function abs (int128 x) internal pure returns (int128) { require (x != MIN_64x64); return x < 0 ? -x : x; } /** * Calculate 1 / x rounding towards zero. Revert on overflow or when x is * zero. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function inv (int128 x) internal pure returns (int128) { require (x != 0); int256 result = int256 (0x100000000000000000000000000000000) / x; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function avg (int128 x, int128 y) internal pure returns (int128) { return int128 ((int256 (x) + int256 (y)) >> 1); } /** * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down. * Revert on overflow or in case x * y is negative. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function gavg (int128 x, int128 y) internal pure returns (int128) { int256 m = int256 (x) * int256 (y); require (m >= 0); require (m < 0x4000000000000000000000000000000000000000000000000000000000000000); return int128 (sqrtu (uint256 (m), uint256 (x) + uint256 (y) >> 1)); } /** * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number * and y is unsigned 256-bit integer number. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @param y uint256 value * @return signed 64.64-bit fixed point number */ function pow (int128 x, uint256 y) internal pure returns (int128) { uint256 absoluteResult; bool negativeResult = false; if (x >= 0) { absoluteResult = powu (uint256 (x) << 63, y); } else { // We rely on overflow behavior here absoluteResult = powu (uint256 (uint128 (-x)) << 63, y); negativeResult = y & 1 > 0; } absoluteResult >>= 63; if (negativeResult) { require (absoluteResult <= 0x80000000000000000000000000000000); return -int128 (absoluteResult); // We rely on overflow behavior here } else { require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); return int128 (absoluteResult); // We rely on overflow behavior here } } /** * Calculate sqrt (x) rounding down. Revert if x < 0. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function sqrt (int128 x) internal pure returns (int128) { require (x >= 0); return int128 (sqrtu (uint256 (x) << 64, 0x10000000000000000)); } /** * Calculate binary logarithm of x. Revert if x <= 0. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function log_2 (int128 x) internal pure returns (int128) { require (x > 0); int256 msb = 0; int256 xc = x; if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; } if (xc >= 0x100000000) { xc >>= 32; msb += 32; } if (xc >= 0x10000) { xc >>= 16; msb += 16; } if (xc >= 0x100) { xc >>= 8; msb += 8; } if (xc >= 0x10) { xc >>= 4; msb += 4; } if (xc >= 0x4) { xc >>= 2; msb += 2; } if (xc >= 0x2) msb += 1; // No need to shift xc anymore int256 result = msb - 64 << 64; uint256 ux = uint256 (x) << 127 - msb; for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) { ux *= ux; uint256 b = ux >> 255; ux >>= 127 + b; result += bit * int256 (b); } return int128 (result); } /** * Calculate natural logarithm of x. Revert if x <= 0. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function ln (int128 x) internal pure returns (int128) { require (x > 0); return int128 ( uint256 (log_2 (x)) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128); } /** * Calculate binary exponent of x. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function exp_2 (int128 x) internal pure returns (int128) { require (x < 0x400000000000000000); // Overflow if (x < -0x400000000000000000) return 0; // Underflow uint256 result = 0x80000000000000000000000000000000; if (x & 0x8000000000000000 > 0) result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128; if (x & 0x4000000000000000 > 0) result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128; if (x & 0x2000000000000000 > 0) result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128; if (x & 0x1000000000000000 > 0) result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128; if (x & 0x800000000000000 > 0) result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128; if (x & 0x400000000000000 > 0) result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128; if (x & 0x200000000000000 > 0) result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128; if (x & 0x100000000000000 > 0) result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128; if (x & 0x80000000000000 > 0) result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128; if (x & 0x40000000000000 > 0) result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128; if (x & 0x20000000000000 > 0) result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128; if (x & 0x10000000000000 > 0) result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128; if (x & 0x8000000000000 > 0) result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128; if (x & 0x4000000000000 > 0) result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128; if (x & 0x2000000000000 > 0) result = result * 0x1000162E525EE054754457D5995292026 >> 128; if (x & 0x1000000000000 > 0) result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128; if (x & 0x800000000000 > 0) result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128; if (x & 0x400000000000 > 0) result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128; if (x & 0x200000000000 > 0) result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128; if (x & 0x100000000000 > 0) result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128; if (x & 0x80000000000 > 0) result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128; if (x & 0x40000000000 > 0) result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128; if (x & 0x20000000000 > 0) result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128; if (x & 0x10000000000 > 0) result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128; if (x & 0x8000000000 > 0) result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128; if (x & 0x4000000000 > 0) result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128; if (x & 0x2000000000 > 0) result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128; if (x & 0x1000000000 > 0) result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128; if (x & 0x800000000 > 0) result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128; if (x & 0x400000000 > 0) result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128; if (x & 0x200000000 > 0) result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128; if (x & 0x100000000 > 0) result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128; if (x & 0x80000000 > 0) result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128; if (x & 0x40000000 > 0) result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128; if (x & 0x20000000 > 0) result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128; if (x & 0x10000000 > 0) result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128; if (x & 0x8000000 > 0) result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128; if (x & 0x4000000 > 0) result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128; if (x & 0x2000000 > 0) result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128; if (x & 0x1000000 > 0) result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128; if (x & 0x800000 > 0) result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128; if (x & 0x400000 > 0) result = result * 0x100000000002C5C85FDF477B662B26945 >> 128; if (x & 0x200000 > 0) result = result * 0x10000000000162E42FEFA3AE53369388C >> 128; if (x & 0x100000 > 0) result = result * 0x100000000000B17217F7D1D351A389D40 >> 128; if (x & 0x80000 > 0) result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128; if (x & 0x40000 > 0) result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128; if (x & 0x20000 > 0) result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128; if (x & 0x10000 > 0) result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128; if (x & 0x8000 > 0) result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128; if (x & 0x4000 > 0) result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128; if (x & 0x2000 > 0) result = result * 0x1000000000000162E42FEFA39F02B772C >> 128; if (x & 0x1000 > 0) result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128; if (x & 0x800 > 0) result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128; if (x & 0x400 > 0) result = result * 0x100000000000002C5C85FDF473DEA871F >> 128; if (x & 0x200 > 0) result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128; if (x & 0x100 > 0) result = result * 0x100000000000000B17217F7D1CF79E949 >> 128; if (x & 0x80 > 0) result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128; if (x & 0x40 > 0) result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128; if (x & 0x20 > 0) result = result * 0x100000000000000162E42FEFA39EF366F >> 128; if (x & 0x10 > 0) result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128; if (x & 0x8 > 0) result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128; if (x & 0x4 > 0) result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128; if (x & 0x2 > 0) result = result * 0x1000000000000000162E42FEFA39EF358 >> 128; if (x & 0x1 > 0) result = result * 0x10000000000000000B17217F7D1CF79AB >> 128; result >>= 63 - (x >> 64); require (result <= uint256 (MAX_64x64)); return int128 (result); } /** * Calculate natural exponent of x. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function exp (int128 x) internal pure returns (int128) { require (x < 0x400000000000000000); // Overflow if (x < -0x400000000000000000) return 0; // Underflow return exp_2 ( int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128)); } /** * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit * integer numbers. Revert on overflow or when y is zero. * * @param x unsigned 256-bit integer number * @param y unsigned 256-bit integer number * @return unsigned 64.64-bit fixed point number */ function divuu (uint256 x, uint256 y) private pure returns (uint128) { require (y != 0); uint256 result; if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) result = (x << 64) / y; else { uint256 msb = 192; uint256 xc = x >> 192; if (xc >= 0x100000000) { xc >>= 32; msb += 32; } if (xc >= 0x10000) { xc >>= 16; msb += 16; } if (xc >= 0x100) { xc >>= 8; msb += 8; } if (xc >= 0x10) { xc >>= 4; msb += 4; } if (xc >= 0x4) { xc >>= 2; msb += 2; } if (xc >= 0x2) msb += 1; // No need to shift xc anymore result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1); require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); uint256 hi = result * (y >> 128); uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); uint256 xh = x >> 192; uint256 xl = x << 64; if (xl < lo) xh -= 1; xl -= lo; // We rely on overflow behavior here lo = hi << 128; if (xl < lo) xh -= 1; xl -= lo; // We rely on overflow behavior here assert (xh == hi >> 128); result += xl / y; } require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); return uint128 (result); } /** * Calculate x^y assuming 0^0 is 1, where x is unsigned 129.127 fixed point * number and y is unsigned 256-bit integer number. Revert on overflow. * * @param x unsigned 129.127-bit fixed point number * @param y uint256 value * @return unsigned 129.127-bit fixed point number */ function powu (uint256 x, uint256 y) private pure returns (uint256) { if (y == 0) return 0x80000000000000000000000000000000; else if (x == 0) return 0; else { int256 msb = 0; uint256 xc = x; if (xc >= 0x100000000000000000000000000000000) { xc >>= 128; msb += 128; } if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; } if (xc >= 0x100000000) { xc >>= 32; msb += 32; } if (xc >= 0x10000) { xc >>= 16; msb += 16; } if (xc >= 0x100) { xc >>= 8; msb += 8; } if (xc >= 0x10) { xc >>= 4; msb += 4; } if (xc >= 0x4) { xc >>= 2; msb += 2; } if (xc >= 0x2) msb += 1; // No need to shift xc anymore int256 xe = msb - 127; if (xe > 0) x >>= xe; else x <<= -xe; uint256 result = 0x80000000000000000000000000000000; int256 re = 0; while (y > 0) { if (y & 1 > 0) { result = result * x; y -= 1; re += xe; if (result >= 0x8000000000000000000000000000000000000000000000000000000000000000) { result >>= 128; re += 1; } else result >>= 127; if (re < -127) return 0; // Underflow require (re < 128); // Overflow } else { x = x * x; y >>= 1; xe <<= 1; if (x >= 0x8000000000000000000000000000000000000000000000000000000000000000) { x >>= 128; xe += 1; } else x >>= 127; if (xe < -127) return 0; // Underflow require (xe < 128); // Overflow } } if (re > 0) result <<= re; else if (re < 0) result >>= -re; return result; } } /** * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer * number. * * @param x unsigned 256-bit integer number * @return unsigned 128-bit integer number */ function sqrtu (uint256 x, uint256 r) private pure returns (uint128) { if (x == 0) return 0; else { require (r > 0); while (true) { uint256 rr = x / r; if (r == rr || r + 1 == rr) return uint128 (r); else if (r == rr + 1) return uint128 (rr); r = r + rr + 1 >> 1; } } } }
// 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); } } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; import "./Context.sol"; import "./IERC20.sol"; import "./SafeMath.sol"; import "./Address.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory name, string memory symbol) public { _name = name; _symbol = symbol; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}; * * Requirements: * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. * * This 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 { } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; import "./Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev 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; } }
Contract Security Audit
- QuillHash - September 15th, 2020 - Security Audit Report
[{"inputs":[{"internalType":"uint256","name":"initialSupply","type":"uint256"},{"internalType":"uint256","name":"_shortMomentumWeight","type":"uint256"},{"internalType":"uint256","name":"_LMweightEx","type":"uint256"},{"internalType":"uint256","name":"_LMweightCo","type":"uint256"},{"internalType":"uint256","name":"factor","type":"uint256"},{"internalType":"uint256","name":"_shortMomentum","type":"uint256"},{"internalType":"uint256","name":"_longMomentum","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getLongMomentum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMomentumAndSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getShortMomentum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBurning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount256","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount256","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000000000000000000000000000aaf96eb9d0d0000000000000000000000000000000000000000000000000000000000000002780b000000000000000000000000000000000000000000000000000000000003feab00000000000000000000000000000000000000000000000000000000000676b50000000000000000000000000000000000000000000000000000000000002710000000000000000000000000000000000000000000000000000110d9316ec000000000000000000000000000000000000000000000000000000110d9316ec000
-----Decoded View---------------
Arg [0] : initialSupply (uint256): 770000000000000000
Arg [1] : _shortMomentumWeight (uint256): 161803
Arg [2] : _LMweightEx (uint256): 261803
Arg [3] : _LMweightCo (uint256): 423605
Arg [4] : factor (uint256): 10000
Arg [5] : _shortMomentum (uint256): 300000000000000
Arg [6] : _longMomentum (uint256): 300000000000000
-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000aaf96eb9d0d0000
Arg [1] : 000000000000000000000000000000000000000000000000000000000002780b
Arg [2] : 000000000000000000000000000000000000000000000000000000000003feab
Arg [3] : 00000000000000000000000000000000000000000000000000000000000676b5
Arg [4] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [5] : 000000000000000000000000000000000000000000000000000110d9316ec000
Arg [6] : 000000000000000000000000000000000000000000000000000110d9316ec000
Deployed Bytecode Sourcemap
174:6379:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2192:81:3;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4228:166;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;3235:98;;;:::i;:::-;;;;;;;;;;;;;;;;;;;5211:328:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;3094:81:3;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;5698:219:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;1086:113;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3391:117:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1684:145:6;;;:::i;:::-;;4440:106:5;;;:::i;:::-;;1061:77:6;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;2386:85:3;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5925:270:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;5024:179;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;1326:232;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5547:143;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1207:111;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1978:240:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2192:81:3;2229:13;2261:5;2254:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2192:81;:::o;4228:166::-;4311:4;4327:39;4336:12;:10;:12::i;:::-;4350:7;4359:6;4327:8;:39::i;:::-;4383:4;4376:11;;4228:166;;;;:::o;3235:98::-;3288:7;3314:12;;3307:19;;3235:98;:::o;5211:328:5:-;5312:4;5329:45;5345:6;5353:9;5364;5329:15;:45::i;:::-;5385:124;5394:6;5402:12;:10;:12::i;:::-;5416:92;5454:9;5416:92;;;;;;;;;;;;;;;;;:11;:19;5428:6;5416:19;;;;;;;;;;;;;;;:33;5436:12;:10;:12::i;:::-;5416:33;;;;;;;;;;;;;;;;:37;;:92;;;;;:::i;:::-;5385:8;:124::i;:::-;5527:4;5520:11;;5211:328;;;;;:::o;3094:81:3:-;3135:5;3159:9;;;;;;;;;;;3152:16;;3094:81;:::o;5698:219:5:-;5787:4;5804:83;5813:12;:10;:12::i;:::-;5827:7;5836:50;5875:10;5836:11;:25;5848:12;:10;:12::i;:::-;5836:25;;;;;;;;;;;;;;;:34;5862:7;5836:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;5804:8;:83::i;:::-;5905:4;5898:11;;5698:219;;;;:::o;1086:113::-;1137:7;1164:27;1174:13;;;;;;;;;;;1189:1;1164:9;:27::i;:::-;1157:34;;1086:113;:::o;3391:117:3:-;3457:7;3483:9;:18;3493:7;3483:18;;;;;;;;;;;;;;;;3476:25;;3391:117;;;:::o;1684:145:6:-;1275:12;:10;:12::i;:::-;1265:22;;:6;;;;;;;;;;;:22;;;1257:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1790:1:::1;1753:40;;1774:6;;;;;;;;;;;1753:40;;;;;;;;;;;;1820:1;1803:6;;:19;;;;;;;;;;;;;;;;;;1684:145::o:0;4440:106:5:-;1275:12:6;:10;:12::i;:::-;1265:22;;:6;;;;;;;;;;;:22;;;1257:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4504:4:5::1;4492:9;;:16;;;;;;;;;;;;;;;;;;4519:19;:17;:19::i;:::-;4440:106::o:0;1061:77:6:-;1099:7;1125:6;;;;;;;;;;;1118:13;;1061:77;:::o;2386:85:3:-;2425:13;2457:7;2450:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2386:85;:::o;5925:270:5:-;6019:4;6036:129;6045:12;:10;:12::i;:::-;6059:7;6068:96;6107:15;6068:96;;;;;;;;;;;;;;;;;:11;:25;6080:12;:10;:12::i;:::-;6068:25;;;;;;;;;;;;;;;:34;6094:7;6068:34;;;;;;;;;;;;;;;;:38;;:96;;;;;:::i;:::-;6036:8;:129::i;:::-;6183:4;6176:11;;5925:270;;;;:::o;5024:179::-;5105:4;5122:51;5138:12;:10;:12::i;:::-;5152:9;5163;5122:15;:51::i;:::-;5191:4;5184:11;;5024:179;;;;:::o;1326:232::-;1381:7;1390;1399;1419:10;1432:27;1442:13;;;;;;;;;;;1457:1;1432:9;:27::i;:::-;1419:40;;1470:10;1483:26;1493:12;;;;;;;;;;;1507:1;1483:9;:26::i;:::-;1470:39;;1528:2;1532;1536:13;:11;:13::i;:::-;1520:30;;;;;;;;1326:232;;;:::o;5547:143::-;5628:7;5655:11;:18;5667:5;5655:18;;;;;;;;;;;;;;;:27;5674:7;5655:27;;;;;;;;;;;;;;;;5648:34;;5547:143;;;;:::o;1207:111::-;1257:7;1284:26;1294:12;;;;;;;;;;;1308:1;1284:9;:26::i;:::-;1277:33;;1207:111;:::o;1978:240:6:-;1275:12;:10;:12::i;:::-;1265:22;;:6;;;;;;;;;;;:22;;;1257:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2086:1:::1;2066:22;;:8;:22;;;;2058:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2175:8;2146:38;;2167:6;;;;;;;;;;;2146:38;;;;;;;;;;;;2203:8;2194:6;;:17;;;;;;;;;;;;;;;;;;1978:240:::0;:::o;8433:208:0:-;8493:6;8522:1;8517;:6;;8508:16;;;;;;8531:14;8548:12;8555:1;8558;8548:5;:12::i;:::-;8531:29;;952:34;8576:29;;:6;:29;;;;8567:39;;;;;;8628:6;8613:22;;;8433:208;;;;:::o;1934:137::-;1987:6;2016:18;2011:1;:23;;2002:33;;;;;;2062:2;2057:1;:7;;2042:23;;1934:137;;;:::o;874:176:7:-;932:7;951:9;967:1;963;:5;951:17;;991:1;986;:6;;978:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1042:1;1035:8;;;874:176;;;;:::o;590:104:2:-;643:15;677:10;670:17;;590:104;:::o;6203:347:5:-;6323:1;6306:19;;:5;:19;;;;6298:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6404:1;6385:21;;:7;:21;;;;6377:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6488:6;6458:11;:18;6470:5;6458:18;;;;;;;;;;;;;;;:27;6477:7;6458:27;;;;;;;;;;;;;;;:36;;;;6526:7;6510:32;;6519:5;6510:32;;;6535:6;6510:32;;;;;;;;;;;;;;;;;;6203:347;;;:::o;4554:462::-;4657:9;;;;;;;;;;;4653:356;;;4683:19;4705:54;4720:9;4731:13;;;;;;;;;;;4746:12;;;;;;;;;;;4705:14;:54::i;:::-;4683:76;;4774:22;4799:26;4813:11;4799:9;:13;;:26;;;;:::i;:::-;4774:51;;4840:26;4846:6;4854:11;4840:5;:26::i;:::-;4881:44;4891:6;4899:9;4910:14;4881:9;:44::i;:::-;4653:356;;;;;4958:39;4968:6;4976:9;4987;4958;:39::i;:::-;4653:356;4554:462;;;:::o;1746:187:7:-;1832:7;1864:1;1859;:6;;1867:12;1851:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1890:9;1906:1;1902;:5;1890:17;;1925:1;1918:8;;;1746:187;;;;;:::o;6088:469:0:-;6147:7;6172:1;6167;:6;6163:20;;;6182:1;6175:8;;;;6163:20;6206:1;6201;:6;;;;6192:16;;;;;;6217:10;6290:2;6250:34;6246:1;:38;6240:1;6231:11;;:54;6230:62;;6217:75;;6299:10;6332:3;6327:1;:8;;6321:1;6312:11;;:24;6299:37;;6360:50;6354:2;:56;;6345:66;;;;;;6425:2;6418:9;;;;;6527:2;6458:66;:71;6445:2;:84;;6436:94;;;;;;6549:2;6544;:7;6537:14;;;;6088:469;;;;;:::o;21005:1257::-;21065:7;21095:1;21090;:6;;21081:16;;;;;;21106:14;21138:50;21133:1;:55;21129:1035;;21218:1;21212:2;21207:1;:7;;21206:13;;;;;;21197:22;;21129:1035;;;21240:11;21254:3;21240:17;;21266:10;21284:3;21279:1;:8;;21266:21;;21306:11;21300:2;:17;21296:48;;21328:2;21321:9;;;;;21339:2;21332:9;;;;21296:48;21362:7;21356:2;:13;21352:44;;21380:2;21373:9;;;;;21391:2;21384:9;;;;21352:44;21414:5;21408:2;:11;21404:40;;21430:1;21423:8;;;;;21440:1;21433:8;;;;21404:40;21462:4;21456:2;:10;21452:39;;21477:1;21470:8;;;;;21487:1;21480:8;;;;21452:39;21509:3;21503:2;:9;21499:38;;21523:1;21516:8;;;;;21533:1;21526:8;;;;21499:38;21555:3;21549:2;:9;21545:23;;21567:1;21560:8;;;;21545:23;21663:1;21656:3;21650;:9;21645:1;21641;:5;:18;;21640:24;21632:3;21626;:9;21621:1;:14;;21620:45;;;;;;21611:54;;21693:34;21683:6;:44;;21674:54;;;;;;21739:10;21767:3;21762:1;:8;;21752:6;:19;21739:32;;21780:10;21807:34;21803:1;:38;21793:6;:49;21780:62;;21853:10;21871:3;21866:1;:8;;21853:21;;21883:10;21901:2;21896:1;:7;;21883:20;;21923:2;21918;:7;21914:20;;;21933:1;21927:7;;;;21914:20;21949:2;21943:8;;;;22008:3;22002:2;:9;;21997:14;;22029:2;22024;:7;22020:20;;;22039:1;22033:7;;;;22020:20;22055:2;22049:8;;;;22125:3;22119:2;:9;;22113:2;:15;22105:24;;;;22155:1;22150:2;:6;;;;;;22140:16;;;;21129:1035;;;;;;;22191:34;22181:6;:44;;22172:54;;;;;;22249:6;22233:23;;;21005:1257;;;;:::o;3051:1381:5:-;3142:7;3162:13;3178:24;3192:9;3178:13;:24::i;:::-;3162:40;;3421:6;3411:16;;:6;:16;;;3407:364;;3457:36;3466:6;3474:18;3488:3;3474:13;:18::i;:::-;3457:8;:36::i;:::-;3448:45;;:6;:45;;;3444:142;;;3521:49;3531:35;3540:6;3548:17;3562:2;3548:13;:17::i;:::-;3531:8;:35::i;:::-;3568:1;3521:9;:49::i;:::-;3514:56;;;;;3444:142;3407:364;;;3631:36;3640:6;3648:18;3662:3;3648:13;:18::i;:::-;3631:8;:36::i;:::-;3622:45;;:6;:45;;;3618:142;;;3695:49;3705:35;3714:6;3722:17;3736:2;3722:13;:17::i;:::-;3705:8;:35::i;:::-;3742:1;3695:9;:49::i;:::-;3688:56;;;;;3618:142;3407:364;3792:22;3816:23;3843:38;3858:6;3866;3874;3843:14;:38::i;:::-;3791:90;;;;3893:17;3912:15;3931:63;3944:6;3952;3960:15;3977:16;3931:12;:63::i;:::-;3892:102;;;;4007:18;4055:16;4069:1;4055:13;:16::i;:::-;4042:29;;:10;:29;;;4038:256;;;4102:36;4111:6;4119:18;4133:3;4119:13;:18::i;:::-;4102:8;:36::i;:::-;4088:50;;4038:256;;;4220:62;4248:6;4256:8;4266:15;4220:27;:62::i;:::-;4206:76;;4038:256;4321:15;4306:12;;:30;;;;;;;;;;;;;;;;;;;;4363:16;4347:13;;:32;;;;;;;;;;;;;;;;;;;;4399:25;4409:11;4422:1;4399:9;:25::i;:::-;4392:32;;;;;;;;3051:1381;;;;;;:::o;1321:134:7:-;1379:7;1405:43;1409:1;1412;1405:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1398:50;;1321:134;;;;:::o;8497:410:3:-;8599:1;8580:21;;:7;:21;;;;8572:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8650:49;8671:7;8688:1;8692:6;8650:20;:49::i;:::-;8731:68;8754:6;8731:68;;;;;;;;;;;;;;;;;:9;:18;8741:7;8731:18;;;;;;;;;;;;;;;;:22;;:68;;;;;:::i;:::-;8710:9;:18;8720:7;8710:18;;;;;;;;;;;;;;;:89;;;;8824:24;8841:6;8824:12;;:16;;:24;;;;:::i;:::-;8809:12;:39;;;;8889:1;8863:37;;8872:7;8863:37;;;8893:6;8863:37;;;;;;;;;;;;;;;;;;8497:410;;:::o;7008:530::-;7131:1;7113:20;;:6;:20;;;;7105:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7214:1;7193:23;;:9;:23;;;;7185:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7267:47;7288:6;7296:9;7307:6;7267:20;:47::i;:::-;7345:71;7367:6;7345:71;;;;;;;;;;;;;;;;;:9;:17;7355:6;7345:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;7325:9;:17;7335:6;7325:17;;;;;;;;;;;;;;;:91;;;;7449:32;7474:6;7449:9;:20;7459:9;7449:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;7426:9;:20;7436:9;7426:20;;;;;;;;;;;;;;;:55;;;;7513:9;7496:35;;7505:6;7496:35;;;7524:6;7496:35;;;;;;;;;;;;;;;;;;7008:530;;;:::o;6825:227:0:-;6882:6;6911:1;6906;:6;;;;6897:16;;;;;;6920:13;6957:1;6936:22;;6951:2;6945:1;6937:10;;:16;;6936:22;;;;;;6920:38;;793:35;6974:19;;:6;:19;;:42;;;;;952:34;6997:19;;:6;:19;;6974:42;6965:52;;;;;;7039:6;7024:22;;;6825:227;;;;:::o;1566:396:5:-;1658:6;1666;1685:15;1713:6;1704:15;;:6;:15;;;1703:43;;1736:10;;;;;;;;;;;1703:43;;;1723:10;;;;;;;;;;;1703:43;1685:61;;1757:12;1772:62;1781:6;1789:44;1798:24;1807:6;1815;1798:8;:24::i;:::-;1824:8;1789;:44::i;:::-;1772:8;:62::i;:::-;1757:77;;1845:12;1860:62;1869:6;1877:44;1886:24;1895:6;1903;1886:8;:24::i;:::-;1912:8;;;;;;;;;;;1877;:44::i;:::-;1860:8;:62::i;:::-;1845:77;;1941:5;1948;1933:21;;;;;;;1566:396;;;;;;:::o;1970:344::-;2073:6;2081;2100:12;2115:34;2124:24;2133:6;2141;2124:8;:24::i;:::-;2115:8;:34::i;:::-;2100:49;;2160:15;2178:32;2187:22;2196:5;2203;2187:8;:22::i;:::-;2178:8;:32::i;:::-;2160:50;;2221:17;2241:25;2250:8;2260:5;2241:8;:25::i;:::-;2221:45;;2285:10;2297:8;2277:29;;;;;;;1970:344;;;;;;;:::o;2322:721::-;2438:6;2625:44;2634:15;2651:17;2665:2;2651:13;:17::i;:::-;2625:8;:44::i;:::-;2613:56;;:8;:56;;;2609:427;;2693:64;2702:6;2710:46;2719:16;2733:1;2719:13;:16::i;:::-;2737:18;2751:3;2737:13;:18::i;:::-;2710:8;:46::i;:::-;2693:8;:64::i;:::-;2686:71;;;;2609:427;2790:17;2810:35;2819:8;2829:15;2810:8;:35::i;:::-;2790:55;;2860:11;2874:76;2883:16;2897:1;2883:13;:16::i;:::-;2901:48;2909:39;2918:10;2930:17;2944:2;2930:13;:17::i;:::-;2909:8;:39::i;:::-;2901:7;:48::i;:::-;2874:8;:76::i;:::-;2860:90;;2972:52;2981:6;2989:34;2998:4;3004:18;3018:3;3004:13;:18::i;:::-;2989:8;:34::i;:::-;2972:8;:52::i;:::-;2965:59;;;;2322:721;;;;;;:::o;10670:92:3:-;;;;:::o;3835:195:0:-;3892:6;3907:13;3935:1;3923:13;;3930:1;3923:9;;:13;3907:29;;793:35;3952:19;;:6;:19;;:42;;;;;952:34;3975:19;;:6;:19;;3952:42;3943:52;;;;;;4017:6;4002:22;;;3835:195;;;;:::o;3418:::-;3475:6;3490:13;3518:1;3506:13;;3513:1;3506:9;;:13;3490:29;;793:35;3535:19;;:6;:19;;:42;;;;;952:34;3558:19;;:6;:19;;3535:42;3526:52;;;;;;3600:6;3585:22;;;3418:195;;;;:::o;9086:120::-;9133:6;793:35;9157:14;;:1;:14;;;;9148:24;;;;;;9190:1;9186;:5;;;:14;;9199:1;9186:14;;;9195:1;9194:2;;9186:14;9179:21;;9086:120;;;:::o;4266:201::-;4323:6;4338:13;4371:2;4366:1;4354:13;;4361:1;4354:9;;:13;:19;;4338:35;;793;4389:19;;:6;:19;;:42;;;;;952:34;4412:19;;:6;:19;;4389:42;4380:52;;;;;;4454:6;4439:22;;;4266:201;;;;:::o;13211:180::-;13257:6;13285:1;13281;:5;;;13272:15;;;;;;13381:3;13343:34;13330:9;13337:1;13330:5;:9::i;:::-;13321:19;;:56;:63;;13296:89;;13211:180;;;:::o;12243:782::-;12292:6;12320:1;12316;:5;;;12307:15;;;;;;12331:10;12352:9;12364:1;12352:13;;;;12382:19;12376:2;:25;12372:56;;12412:2;12405:9;;;;;12423:2;12416:9;;;;12372:56;12444:11;12438:2;:17;12434:48;;12466:2;12459:9;;;;;12477:2;12470:9;;;;12434:48;12498:7;12492:2;:13;12488:44;;12516:2;12509:9;;;;;12527:2;12520:9;;;;12488:44;12548:5;12542:2;:11;12538:40;;12564:1;12557:8;;;;;12574:1;12567:8;;;;12538:40;12594:4;12588:2;:10;12584:39;;12609:1;12602:8;;;;;12619:1;12612:8;;;;12584:39;12639:3;12633:2;:9;12629:38;;12653:1;12646:8;;;;;12663:1;12656:8;;;;12629:38;12683:3;12677:2;:9;12673:23;;12695:1;12688:8;;;;12673:23;12737:13;12765:2;12759;12753:3;:8;:14;;12737:30;;12774:10;12808:3;12802;:9;12796:1;12787:11;;:24;;;;;;;;;;12774:37;;12823:10;12836:18;12823:31;;12818:171;12862:1;12856:3;:7;12818:171;;;12891:2;12885:8;;;;12902:9;12920:3;12914:2;:9;;12902:21;;12945:1;12939:3;:7;12932:14;;;;;12979:1;12965:3;:16;12955:26;;;;12818:171;12873:1;12865:9;;;;;12818:171;;;;13012:6;12997:22;;;;;;12243:782;;;:::o
Swarm Source
ipfs://ae3ab1acab4a6a7b5465e9a1db9c3e425a43d4e681c312ba2be7906e37a83838
Loading...
Loading
Loading...
Loading
OVERVIEW
Momentum (XMM) is a deflationary token whereby every transfer will burn some tokens and cause the total supply to decrease over time.Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.