PulseChain Explorer - BlockScout

Contract Address

Is Yul contract

No

Yes

Contract Name

Include nightly builds

No

Yes

Compiler

EVM Version

Optimization

No

Yes

Optimization runs

Enter the Solidity Contract Code

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IUniswapV2Pair {
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function token0() external view returns (address);
    function token1() external view returns (address);
}

interface IERC20Decimals {
    function decimals() external view returns (uint8);
}

library FixedPoint {
    struct uq112x112 { uint224 _x; }
    struct uq144x112 { uint _x; }
    uint8 private constant RESOLUTION = 112;

// Optimized RPower for reward calculation (Logarithmic time complexity)
    // Calculates x^n with 1e18 precision to match contract constants
    function rpow(uint x, uint n) internal pure returns (uint z) {
        z = n % 2 != 0 ? x : 1e18;
        for (n /= 2; n != 0; n /= 2) {
            x = (x * x) / 1e18;
            if (n % 2 != 0) z = (z * x) / 1e18;
        }
    }
}

library UniswapV2OracleLibrary {
    using FixedPoint for *;

function currentBlockTimestamp() internal view returns (uint) { return block.timestamp; }

struct PriceData { uint price0Cumulative; uint price1Cumulative; }

contract TWAPOracle {
    using FixedPoint for *;

struct Observation {
        uint timestamp;
        uint price0Cumulative;
        uint price1Cumulative;
    }

struct ReferenceStable {
        address stable;
        address pair;
        bool isWplsToken0;
        uint8 stableDecimals;
        bool active;
    }

struct PairInfo {
        address pair;
        bool isToken0;
    }

error UnknownPair();
    error PairAlreadyAdded();
    error InvalidPair();
    error InvalidTWAPWindow();
    error Unauthorized();
    error PeriodNotElapsed();
    error RewardsNotEnabled();
    error InsufficientBalanceForReward();
    error AlreadyLaunched();
    error NoValidReferences();
    error StalePrice();

address public immutable wpls;

mapping(address => uint) public wards;
    function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); }
    function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); }
    modifier auth() {
        if (wards[msg.sender] != 1) revert Unauthorized();
        _;
    }

bool public rewardsEnabled;

uint public constant PERIOD_SIZE = 3600;
    uint public constant MIN_WINDOW = 3600;
    uint public constant MAX_WINDOW = 18000;
    uint public constant REWARD_WINDOW = 5400; // Peak at 1.5hr total (0.5hr effective)
    uint public constant UPDATE_THRESHOLD = 7200;

uint public constant DECAY_RATE = 500000000000000000; // 0.5
    uint public constant DECAY_PERIOD = 900;

string public constant name = "TWAP";
    string public constant symbol = "TWAP";
    uint8 public constant decimals = 18;
    uint public totalSupply;
    mapping(address => uint) public balanceOf;
    mapping(address => mapping(address => uint)) public allowance;

uint public constant BASE_REWARD_RATE = 13888888888888888;
    uint public constant INITIAL_SUPPLY = 1_000_000 * 10 ** 18;
    uint public constant MIN_HOLDING_DIVISOR = 555;

// OPTIMIZED: Circular Buffer Data
    mapping(address => Observation[5]) public observations;     // pair => observations
    mapping(address => uint8) public observationHeads;          // pair => next write index (0-4)
    
    // OPTIMIZED: Unified List for Updates
    address[] public livePairs;
    
    mapping(address => PairInfo) public tokenToPairInfo;
    address[] public pricedTokens;

// REMOVED: mapping(address => uint) public lastUpdateTimestamp; (Redundant, use observation timestamp)

ReferenceStable[] public referenceStables;

event PriceUpdated(address indexed token, address indexed pair, uint price0Cumulative, uint price1Cumulative, uint timestamp);
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
    event Reward(address indexed updater, uint amount);
    event RewardsLaunched();
    event Rely(address indexed usr);
    event Deny(address indexed usr);
    event ReferenceAdded(address indexed stable, address indexed pair, bool isWplsToken0, uint8 stableDecimals);
    event ReferenceUpdated(uint indexed index, bool active);
    event DirectPairAdded(address indexed token, address indexed pair, bool isToken0);
    event DirectPairRemoved(address indexed token);
    event SuperUpdate(uint timestamp, uint updatedPairs);

uint public lastSuperUpdateTimestamp;

constructor(address _wpls) {
        wpls = _wpls;
        wards[msg.sender] = 1;
        emit Rely(msg.sender);
        totalSupply = INITIAL_SUPPLY;
        balanceOf[msg.sender] = INITIAL_SUPPLY;
        emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
    }

function getMinHoldingForReward() public view returns (uint) { return totalSupply / MIN_HOLDING_DIVISOR; }

function launch() external auth {
        if (rewardsEnabled) revert AlreadyLaunched();
        rewardsEnabled = true;
        emit RewardsLaunched();
    }

// === REFERENCE STABLES ===
    function addReferenceStable(address stable, address pair, bool isWplsToken0) external auth {
        address token0 = IUniswapV2Pair(pair).token0();
        address token1 = IUniswapV2Pair(pair).token1();
        if ((isWplsToken0 && token0 != wpls) || (!isWplsToken0 && token1 != wpls)) revert InvalidPair();

uint8 stableDecimals = IERC20Decimals(stable).decimals();
        if (stableDecimals > 18) revert("Stable decimals >18");

referenceStables.push(ReferenceStable(stable, pair, isWplsToken0, stableDecimals, true));

// Initialize Observation
        (uint price0Cumulative, uint price1Cumulative, ) = UniswapV2OracleLibrary.currentCumulativePrices(pair);
        observations[pair][0] = Observation(block.timestamp, price0Cumulative, price1Cumulative);
        observationHeads[pair] = 1; // Next write goes to index 1
        
        // OPTIMIZATION: Add to unified list
        livePairs.push(pair);

emit ReferenceAdded(stable, pair, isWplsToken0, stableDecimals);
    }

function updateReference(uint index, bool active) external auth {
        if (index >= referenceStables.length) revert("Invalid index");
        referenceStables[index].active = active;
        emit ReferenceUpdated(index, active);
    }

// === DIRECT PAIRS ===
    function addDirectPair(address token, address pair, bool isToken0) external auth {
        if (tokenToPairInfo[token].pair != address(0)) revert PairAlreadyAdded();

address token0 = IUniswapV2Pair(pair).token0();
        address token1 = IUniswapV2Pair(pair).token1();
        if ((isToken0 && token0 != token) || (!isToken0 && token1 != token)) revert InvalidPair();

tokenToPairInfo[token] = PairInfo(pair, isToken0);
        pricedTokens.push(token);

// Initialize Observation
        (uint price0Cumulative, uint price1Cumulative, ) = UniswapV2OracleLibrary.currentCumulativePrices(pair);
        observations[pair][0] = Observation(block.timestamp, price0Cumulative, price1Cumulative);
        observationHeads[pair] = 1;

// OPTIMIZATION: Add to unified list
        livePairs.push(pair);

emit DirectPairAdded(token, pair, isToken0);
    }

function removeDirectPair(address token) external auth {
        PairInfo memory info = tokenToPairInfo[token];
        if (info.pair == address(0)) revert UnknownPair();

delete tokenToPairInfo[token];
        
        // OPTIMIZATION: Remove from livePairs
        _removeLivePair(info.pair);

// Clean up storage for gas refund
        delete observations[info.pair];
        delete observationHeads[info.pair];

// Remove from pricedTokens
        for (uint i = 0; i < pricedTokens.length; i++) {
            if (pricedTokens[i] == token) {
                pricedTokens[i] = pricedTokens[pricedTokens.length - 1];
                pricedTokens.pop();
                break;
            }
        }
        emit DirectPairRemoved(token);
    }

// Helper to remove from livePairs array
    function _removeLivePair(address pair) internal {
        for (uint i = 0; i < livePairs.length; i++) {
            if (livePairs[i] == pair) {
                livePairs[i] = livePairs[livePairs.length - 1];
                livePairs.pop();
                break;
            }
        }
    }

// === OPTIMIZED: superUpdate ===
    function superUpdate() public {
        uint currentTimestamp = block.timestamp;

if (currentTimestamp - lastSuperUpdateTimestamp < MIN_WINDOW) {
            revert PeriodNotElapsed();
        }

// OPTIMIZATION: Single Pass Collection
        // We allocate max memory size to avoid resizing costs. 
        // Since we have < 100 pairs, this is acceptable gas wise vs dynamic pushing.
        uint totalPairs = livePairs.length;
        address[] memory pairsToUpdate = new address[](totalPairs);
        uint updateCount = 0;

for (uint i = 0; i < totalPairs; ) {
            address pair = livePairs[i];
            
            // Get the index of the most recently written observation
            uint8 head = observationHeads[pair];
            uint8 lastIdx = (head == 0) ? 4 : head - 1;
            
            // Check timestamp of the latest observation instead of a separate mapping
            if (currentTimestamp - observations[pair][lastIdx].timestamp >= PERIOD_SIZE) {
                pairsToUpdate[updateCount] = pair;
                unchecked { ++updateCount; }
            }
            unchecked { ++i; }
        }

if (updateCount > 0) {
            // Create a properly sized array for the batch call
            address[] memory activeBatch = new address[](updateCount);
            for (uint i = 0; i < updateCount; i++) {
                activeBatch[i] = pairsToUpdate[i];
            }

(UniswapV2OracleLibrary.PriceData[] memory prices, ) = 
                UniswapV2OracleLibrary.batchCumulativePrices(activeBatch);

for (uint i = 0; i < updateCount; i++) {
                _applyUpdate(activeBatch[i], prices[i], currentTimestamp);
            }

if (rewardsEnabled && balanceOf[msg.sender] >= getMinHoldingForReward()) {
                uint reward = calculateReward(currentTimestamp);
                if (reward > 0) _mintReward(msg.sender, reward);
            }
        }

lastSuperUpdateTimestamp = currentTimestamp;
        emit SuperUpdate(currentTimestamp, updateCount);
    }

// === OPTIMIZED: Circular Buffer Update ===
    function _applyUpdate(address pair, UniswapV2OracleLibrary.PriceData memory price, uint blockTimestamp) private {
        uint8 head = observationHeads[pair];
        
        // Overwrite the oldest observation
        observations[pair][head] = Observation(
            block.timestamp, 
            price.price0Cumulative, 
            price.price1Cumulative
        );

// Move head forward (0 -> 1 -> 2 -> 3 -> 4 -> 0)
        observationHeads[pair] = (head + 1) % 5;
        
        emit PriceUpdated(address(0), pair, price.price0Cumulative, price.price1Cumulative, blockTimestamp);
    }

// === OPTIMIZED: Read & Sort ===
    function getMedianPrice(address pair, bool needPrice0, uint currentCumulative, uint currentTimestamp) internal view returns (uint224 medianPrice) {
        // 1. Load all 5 observations into memory
        Observation[5] memory obsArray;
        for(uint i=0; i<5; i++) {
            obsArray[i] = observations[pair][i];
        }

// 2. Sort by timestamp (Descending: Newest first)
        // Using insertion sort for efficiency on small arrays
        for (uint i = 1; i < 5; ) {
            Observation memory key = obsArray[i];
            uint j = i;
            while (j > 0 && obsArray[j-1].timestamp < key.timestamp) {
                obsArray[j] = obsArray[j-1];
                j--;
            }
            obsArray[j] = key;
            unchecked { ++i; }
        }

// 3. Calculate Segment TWAPs
        uint224[] memory segmentPrices = new uint224[](5);
        uint count = 0;
        uint prevCum = currentCumulative;
        uint prevTs = currentTimestamp;

for (uint i = 0; i < 5; i++) {
            if (obsArray[i].timestamp == 0) continue;
            uint timeElapsed = prevTs - obsArray[i].timestamp;
            
            if (timeElapsed < MIN_WINDOW || timeElapsed > MAX_WINDOW) continue;

uint obsCum = needPrice0 ? obsArray[i].price0Cumulative : obsArray[i].price1Cumulative;
            uint segmentTWAP = (prevCum - obsCum) / timeElapsed;
            segmentPrices[count] = uint224(segmentTWAP);
            count++;

prevCum = obsCum;
            prevTs = obsArray[i].timestamp;
        }

if (count == 0) revert InvalidTWAPWindow();

// Sort Segment Prices
        for (uint i = 1; i < count; ) {
            uint224 key = segmentPrices[i];
            uint j = i;
            while (j > 0 && segmentPrices[j - 1] > key) {
                segmentPrices[j] = segmentPrices[j - 1];
                j--;
            }
            segmentPrices[j] = key;
            unchecked { ++i; }
        }

if (count % 2 == 1) {
            medianPrice = segmentPrices[count / 2];
        } else {
            medianPrice = (segmentPrices[count / 2 - 1] + segmentPrices[count / 2]) / 2;
        }
    }

function _getNormalizedPriceFromRef(ReferenceStable memory ref) internal view returns (uint priceNormalized) {
        (uint112 reserve0, uint112 reserve1, ) = IUniswapV2Pair(ref.pair).getReserves();
        uint wplsReserve = ref.isWplsToken0 ? uint(reserve0) : uint(reserve1);
        if (wplsReserve == 0) return 0;

(uint price0Cumulative, uint price1Cumulative, uint blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(ref.pair);
        bool needPrice0 = ref.isWplsToken0;
        uint224 medianPrice = getMedianPrice(ref.pair, needPrice0, needPrice0 ? price0Cumulative : price1Cumulative, blockTimestamp);

FixedPoint.uq144x112 memory fullPrice = FixedPoint.uq112x112(medianPrice).mul(1e18);
        uint priceNative = FixedPoint.decode144(fullPrice);

uint decimalAdjustment = 10 ** (18 - ref.stableDecimals);
        priceNormalized = priceNative * decimalAdjustment;
    }

function getWplsPriceInUsd() public view returns (uint priceWad) {
        uint validCount = 0;
        uint[] memory prices = new uint[](referenceStables.length);

for (uint i = 0; i < referenceStables.length; i++) {
            ReferenceStable memory ref = referenceStables[i];
            if (!ref.active) continue;

uint price = _getNormalizedPriceFromRef(ref);
            if (price == 0) continue;

prices[validCount] = price;
            validCount++;
        }

if (validCount == 0) revert NoValidReferences();

// Sort Prices
        for (uint i = 0; i < validCount; i++) {
            for (uint j = i + 1; j < validCount; j++) {
                if (prices[i] > prices[j]) {
                    uint temp = prices[i];
                    prices[i] = prices[j];
                    prices[j] = temp;
                }
            }
        }

if (validCount % 2 == 1) {
            priceWad = prices[validCount / 2];
        } else {
            priceWad = (prices[validCount / 2 - 1] + prices[validCount / 2]) / 2;
        }
    }

function getPriceInUsd(address token, uint amountIn) public view returns (uint amountOutUsd) {
        if (token == wpls) {
            return (amountIn * getWplsPriceInUsd()) / 1e18;
        }

PairInfo memory info = tokenToPairInfo[token];
        if (info.pair != address(0)) {
            (uint price0Cumulative, uint price1Cumulative, uint blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(info.pair);
            uint224 medianPrice = getMedianPrice(info.pair, info.isToken0, info.isToken0 ? price0Cumulative : price1Cumulative, blockTimestamp);

FixedPoint.uq144x112 memory temp = FixedPoint.uq112x112(medianPrice).mul(amountIn);
            uint amountInWpls = FixedPoint.decode144(temp);

amountOutUsd = (amountInWpls * getWplsPriceInUsd()) / 1e18;
        } else {
            revert UnknownPair();
        }
    }

function _mintReward(address updater, uint reward) private {
        if (!rewardsEnabled) revert RewardsNotEnabled();
        uint holding = balanceOf[updater];
        uint minHolding = getMinHoldingForReward();
        if (holding < minHolding) revert InsufficientBalanceForReward();
        if (reward == 0) return;
        totalSupply += reward;
        balanceOf[updater] += reward;
        emit Reward(updater, reward);
    }

// === OPTIMIZED REWARD MATH ===
    function calculateReward(uint currentTime) internal view returns (uint) {
        if (!rewardsEnabled) return 0;
        uint timeSinceLast = currentTime - lastSuperUpdateTimestamp;
        if (timeSinceLast < MIN_WINDOW) return 0;

uint effectiveTime = timeSinceLast - MIN_WINDOW;
        uint peakEffectiveTime = REWARD_WINDOW - MIN_WINDOW;

uint timeBasedReward;
        if (effectiveTime <= peakEffectiveTime) {
            timeBasedReward = BASE_REWARD_RATE * effectiveTime;
        } else {
            uint cappedExtra = effectiveTime - peakEffectiveTime;
            
            // OPTIMIZATION: Use Logarithmic Power function instead of loop
            uint decayIntervals = cappedExtra / DECAY_PERIOD;
            
            // rpow calculates (DECAY_RATE ^ decayIntervals)
            // DECAY_RATE is 5e17 (0.5), rpow expects 1e18 precision
            uint decayFactor = FixedPoint.rpow(DECAY_RATE, decayIntervals);
            
            uint peakReward = BASE_REWARD_RATE * peakEffectiveTime;
            timeBasedReward = (peakReward * decayFactor) / 1e18;
        }

uint supplyFactor = 1e18;
        if (totalSupply > INITIAL_SUPPLY) {
            uint a = INITIAL_SUPPLY;
            uint b = totalSupply;
            supplyFactor = (2 * a * 1e18) / (a + b);
        }
        return (timeBasedReward * supplyFactor) / 1e18;
    }

// === ERC20 IMPLEMENTATION ===
    function transfer(address to, uint256 value) external returns (bool) {
        require(to != address(0), "ERC20: transfer to the zero address");
        require(balanceOf[msg.sender] >= value, "ERC20: transfer amount exceeds balance");

balanceOf[msg.sender] -= value;
        balanceOf[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }

function transferFrom(address from, address to, uint256 value) external returns (bool) {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(balanceOf[from] >= value, "ERC20: transfer amount exceeds balance");
        require(allowance[from][msg.sender] >= value, "ERC20: insufficient allowance");

balanceOf[from] -= value;
        balanceOf[to] += value;
        allowance[from][msg.sender] -= value;
        emit Transfer(from, to, value);
        return true;
    }

function approve(address spender, uint256 value) external returns (bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

// === VIEW HELPERS ===
    function getTokens() external view returns (address[] memory) { return pricedTokens; }
    function getReferenceCount() external view returns (uint) { return referenceStables.length; }
    function getPricedTokenCount() external view returns (uint) { return pricedTokens.length; }
    function getCurrentReward() external view returns (uint) { return calculateReward(block.timestamp); }
}

Try to fetch constructor arguments automatically

No

Yes

ABI-encoded Constructor Arguments (if required by the contract)

New Solidity Smart Contract Verification

Contract Libraries