Contract 0xAed37a234cc880a9e3D9Fd9022013eE0A419493e

 
 
Txn Hash
Method
Block
From
To
Value
0xfdbdd4a3236bf14fc868ae928bdffd12fd317d2753c06a69f6bcbc2987c31cd70x60c06040137115112021-11-29 23:43:50363 days 18 hrs agoEuler: Deployer IN  Create: Liquidation0 Ether0.44064217 136.29867791
[ Download CSV Export 
View more zero value Internal Transactions in Advanced View mode
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.

Contract Source Code Verified (Exact Match)

Contract Name:
Liquidation

Compiler Version
v0.8.10+commit.fc410830

Optimization Enabled:
Yes with 1000000 runs

Other Settings:
default evmVersion, BSL 1.1 license
File 1 of 13 : Liquidation.sol
// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.8.0;

import "../BaseLogic.sol";


/// @notice Liquidate users who are in collateral violation to protect lenders
contract Liquidation is BaseLogic {
    constructor(bytes32 moduleGitCommit_) BaseLogic(MODULEID__LIQUIDATION, moduleGitCommit_) {}

    // How much of a liquidation is credited to the underlying's reserves.
    uint public constant UNDERLYING_RESERVES_FEE = 0.02 * 1e18;

    // Maximum discount that can be awarded under any conditions.
    uint public constant MAXIMUM_DISCOUNT = 0.20 * 1e18;

    // How much faster the booster grows for a fully funded supplier. Partially-funded suppliers
    // have this scaled proportional to their free-liquidity divided by the violator's liability.
    uint public constant DISCOUNT_BOOSTER_SLOPE = 2 * 1e18;

    // How much booster discount can be awarded beyond the base discount.
    uint public constant MAXIMUM_BOOSTER_DISCOUNT = 0.025 * 1e18;

    // Post-liquidation target health score that limits maximum liquidation sizes. Must be >= 1.
    uint public constant TARGET_HEALTH = 1.25 * 1e18;


    /// @notice Information about a prospective liquidation opportunity
    struct LiquidationOpportunity {
        uint repay;
        uint yield;
        uint healthScore;

        // Only populated if repay > 0:
        uint baseDiscount;
        uint discount;
        uint conversionRate;
    }

    struct LiquidationLocals {
        address liquidator;
        address violator;
        address underlying;
        address collateral;

        uint underlyingPrice;
        uint collateralPrice;

        LiquidationOpportunity liqOpp;

        uint repayPreFees;
    }

    function computeLiqOpp(LiquidationLocals memory liqLocs) private {
        require(!isSubAccountOf(liqLocs.violator, liqLocs.liquidator), "e/liq/self-liquidation");
        require(isEnteredInMarket(liqLocs.violator, liqLocs.underlying), "e/liq/violator-not-entered-underlying");
        require(isEnteredInMarket(liqLocs.violator, liqLocs.collateral), "e/liq/violator-not-entered-collateral");

        liqLocs.underlyingPrice = getAssetPrice(liqLocs.underlying);
        liqLocs.collateralPrice = getAssetPrice(liqLocs.collateral);

        LiquidationOpportunity memory liqOpp = liqLocs.liqOpp;

        AssetStorage storage underlyingAssetStorage = eTokenLookup[underlyingLookup[liqLocs.underlying].eTokenAddress];
        AssetCache memory underlyingAssetCache = loadAssetCache(liqLocs.underlying, underlyingAssetStorage);

        AssetStorage storage collateralAssetStorage = eTokenLookup[underlyingLookup[liqLocs.collateral].eTokenAddress];
        AssetCache memory collateralAssetCache = loadAssetCache(liqLocs.collateral, collateralAssetStorage);

        liqOpp.repay = liqOpp.yield = 0;

        (uint collateralValue, uint liabilityValue) = getAccountLiquidity(liqLocs.violator);

        if (liabilityValue == 0) {
            liqOpp.healthScore = type(uint).max;
            return; // no violation
        }

        liqOpp.healthScore = collateralValue * 1e18 / liabilityValue;

        if (collateralValue >= liabilityValue) {
            return; // no violation
        }

        // At this point healthScore must be < 1 since collateral < liability

        // Compute discount

        {
            uint baseDiscount = UNDERLYING_RESERVES_FEE + (1e18 - liqOpp.healthScore);

            uint discountBooster = computeDiscountBooster(liqLocs.liquidator, liabilityValue);

            uint discount = baseDiscount * discountBooster / 1e18;

            if (discount > (baseDiscount + MAXIMUM_BOOSTER_DISCOUNT)) discount = baseDiscount + MAXIMUM_BOOSTER_DISCOUNT;
            if (discount > MAXIMUM_DISCOUNT) discount = MAXIMUM_DISCOUNT;

            liqOpp.baseDiscount = baseDiscount;
            liqOpp.discount = discount;
            liqOpp.conversionRate = liqLocs.underlyingPrice * 1e18 / liqLocs.collateralPrice * 1e18 / (1e18 - discount);
        }

        // Determine amount to repay to bring user to target health

        AssetConfig memory underlyingConfig = resolveAssetConfig(liqLocs.underlying);
        AssetConfig memory collateralConfig = resolveAssetConfig(liqLocs.collateral);

        {
            uint liabilityValueTarget = liabilityValue * TARGET_HEALTH / 1e18;

            // These factors are first converted into standard 1e18-scale fractions, then adjusted according to TARGET_HEALTH and the discount:
            uint borrowAdj = TARGET_HEALTH * CONFIG_FACTOR_SCALE / underlyingConfig.borrowFactor;
            uint collateralAdj = 1e18 * uint(collateralConfig.collateralFactor) / CONFIG_FACTOR_SCALE * 1e18 / (1e18 - liqOpp.discount);

            if (borrowAdj <= collateralAdj) {
                liqOpp.repay = type(uint).max;
            } else {
                // liabilityValueTarget >= liabilityValue > collateralValue
                uint maxRepayInReference = (liabilityValueTarget - collateralValue) * 1e18 / (borrowAdj - collateralAdj);
                liqOpp.repay = maxRepayInReference * 1e18 / liqLocs.underlyingPrice;
            }
        }

        // Limit repay to current owed
        // This can happen when there are multiple borrows and liquidating this one won't bring the violator back to solvency

        {
            uint currentOwed = getCurrentOwed(underlyingAssetStorage, underlyingAssetCache, liqLocs.violator);
            if (liqOpp.repay > currentOwed) liqOpp.repay = currentOwed;
        }

        // Limit yield to borrower's available collateral, and reduce repay if necessary
        // This can happen when borrower has multiple collaterals and seizing all of this one won't bring the violator back to solvency

        liqOpp.yield = liqOpp.repay * liqOpp.conversionRate / 1e18;

        {
            uint collateralBalance = balanceToUnderlyingAmount(collateralAssetCache, collateralAssetStorage.users[liqLocs.violator].balance);

            if (collateralBalance < liqOpp.yield) {
                liqOpp.repay = collateralBalance * 1e18 / liqOpp.conversionRate;
                liqOpp.yield = collateralBalance;
            }
        }

        // Adjust repay to account for reserves fee

        liqLocs.repayPreFees = liqOpp.repay;
        liqOpp.repay = liqOpp.repay * (1e18 + UNDERLYING_RESERVES_FEE) / 1e18;
    }


    // Returns 1e18-scale fraction > 1 representing how much faster the booster grows for this liquidator

    function computeDiscountBooster(address liquidator, uint violatorLiabilityValue) private returns (uint) {
        uint booster = getUpdatedAverageLiquidityWithDelegate(liquidator) * 1e18 / violatorLiabilityValue;
        if (booster > 1e18) booster = 1e18;

        booster = booster * (DISCOUNT_BOOSTER_SLOPE - 1e18) / 1e18;

        return booster + 1e18;
    }


    /// @notice Checks to see if a liquidation would be profitable, without actually doing anything
    /// @param liquidator Address that will initiate the liquidation
    /// @param violator Address that may be in collateral violation
    /// @param underlying Token that is to be repayed
    /// @param collateral Token that is to be seized
    /// @return liqOpp The details about the liquidation opportunity
    function checkLiquidation(address liquidator, address violator, address underlying, address collateral) external nonReentrant returns (LiquidationOpportunity memory liqOpp) {
        LiquidationLocals memory liqLocs;

        liqLocs.liquidator = liquidator;
        liqLocs.violator = violator;
        liqLocs.underlying = underlying;
        liqLocs.collateral = collateral;

        computeLiqOpp(liqLocs);

        return liqLocs.liqOpp;
    }


    /// @notice Attempts to perform a liquidation
    /// @param violator Address that may be in collateral violation
    /// @param underlying Token that is to be repayed
    /// @param collateral Token that is to be seized
    /// @param repay The amount of underlying DTokens to be transferred from violator to sender, in units of underlying
    /// @param minYield The minimum acceptable amount of collateral ETokens to be transferred from violator to sender, in units of collateral
    function liquidate(address violator, address underlying, address collateral, uint repay, uint minYield) external nonReentrant {
        require(accountLookup[violator].deferLiquidityStatus == DEFERLIQUIDITY__NONE, "e/liq/violator-liquidity-deferred");

        address liquidator = unpackTrailingParamMsgSender();

        emit RequestLiquidate(liquidator, violator, underlying, collateral, repay, minYield);

        updateAverageLiquidity(liquidator);
        updateAverageLiquidity(violator);


        LiquidationLocals memory liqLocs;

        liqLocs.liquidator = liquidator;
        liqLocs.violator = violator;
        liqLocs.underlying = underlying;
        liqLocs.collateral = collateral;

        computeLiqOpp(liqLocs);


        executeLiquidation(liqLocs, repay, minYield);
    }

    function executeLiquidation(LiquidationLocals memory liqLocs, uint desiredRepay, uint minYield) private {
        require(desiredRepay <= liqLocs.liqOpp.repay, "e/liq/excessive-repay-amount");


        uint repay;

        {
            AssetStorage storage underlyingAssetStorage = eTokenLookup[underlyingLookup[liqLocs.underlying].eTokenAddress];
            AssetCache memory underlyingAssetCache = loadAssetCache(liqLocs.underlying, underlyingAssetStorage);

            if (desiredRepay == liqLocs.liqOpp.repay) repay = liqLocs.repayPreFees;
            else repay = desiredRepay * (1e18 * 1e18 / (1e18 + UNDERLYING_RESERVES_FEE)) / 1e18;

            {
                uint repayExtra = desiredRepay - repay;

                // Liquidator takes on violator's debt:

                transferBorrow(underlyingAssetStorage, underlyingAssetCache, underlyingAssetStorage.dTokenAddress, liqLocs.violator, liqLocs.liquidator, repay);

                // Extra debt is minted and assigned to liquidator:

                increaseBorrow(underlyingAssetStorage, underlyingAssetCache, underlyingAssetStorage.dTokenAddress, liqLocs.liquidator, repayExtra);

                // The underlying's reserve is credited to compensate for this extra debt:

                {
                    uint poolAssets = underlyingAssetCache.poolSize + (underlyingAssetCache.totalBorrows / INTERNAL_DEBT_PRECISION);
                    uint newTotalBalances = poolAssets * underlyingAssetCache.totalBalances / (poolAssets - repayExtra);
                    increaseReserves(underlyingAssetStorage, underlyingAssetCache, newTotalBalances - underlyingAssetCache.totalBalances);
                }
            }

            logAssetStatus(underlyingAssetCache);
        }


        uint yield;

        {
            AssetStorage storage collateralAssetStorage = eTokenLookup[underlyingLookup[liqLocs.collateral].eTokenAddress];
            AssetCache memory collateralAssetCache = loadAssetCache(liqLocs.collateral, collateralAssetStorage);

            yield = repay * liqLocs.liqOpp.conversionRate / 1e18;
            require(yield >= minYield, "e/liq/min-yield");

            // Liquidator gets violator's collateral:

            address eTokenAddress = underlyingLookup[collateralAssetCache.underlying].eTokenAddress;

            transferBalance(collateralAssetStorage, collateralAssetCache, eTokenAddress, liqLocs.violator, liqLocs.liquidator, underlyingAmountToBalance(collateralAssetCache, yield));

            logAssetStatus(collateralAssetCache);
        }


        // Since liquidator is taking on new debt, liquidity must be checked:

        checkLiquidity(liqLocs.liquidator);

        emitLiquidationLog(liqLocs, repay, yield);
    }

    function emitLiquidationLog(LiquidationLocals memory liqLocs, uint repay, uint yield) private {
        emit Liquidation(liqLocs.liquidator, liqLocs.violator, liqLocs.underlying, liqLocs.collateral, repay, yield, liqLocs.liqOpp.healthScore, liqLocs.liqOpp.baseDiscount, liqLocs.liqOpp.discount);
    }
}

File 2 of 13 : BaseLogic.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./BaseModule.sol";
import "./BaseIRM.sol";
import "./Interfaces.sol";
import "./Utils.sol";
import "./vendor/RPow.sol";
import "./IRiskManager.sol";


abstract contract BaseLogic is BaseModule {
    constructor(uint moduleId_, bytes32 moduleGitCommit_) BaseModule(moduleId_, moduleGitCommit_) {}


    // Account auth

    function getSubAccount(address primary, uint subAccountId) internal pure returns (address) {
        require(subAccountId < 256, "e/sub-account-id-too-big");
        return address(uint160(primary) ^ uint160(subAccountId));
    }

    function isSubAccountOf(address primary, address subAccount) internal pure returns (bool) {
        return (uint160(primary) | 0xFF) == (uint160(subAccount) | 0xFF);
    }



    // Entered markets array

    function getEnteredMarketsArray(address account) internal view returns (address[] memory) {
        uint32 numMarketsEntered = accountLookup[account].numMarketsEntered;
        address firstMarketEntered = accountLookup[account].firstMarketEntered;

        address[] memory output = new address[](numMarketsEntered);
        if (numMarketsEntered == 0) return output;

        address[MAX_POSSIBLE_ENTERED_MARKETS] storage markets = marketsEntered[account];

        output[0] = firstMarketEntered;

        for (uint i = 1; i < numMarketsEntered; ++i) {
            output[i] = markets[i];
        }

        return output;
    }

    function isEnteredInMarket(address account, address underlying) internal view returns (bool) {
        uint32 numMarketsEntered = accountLookup[account].numMarketsEntered;
        address firstMarketEntered = accountLookup[account].firstMarketEntered;

        if (numMarketsEntered == 0) return false;
        if (firstMarketEntered == underlying) return true;

        address[MAX_POSSIBLE_ENTERED_MARKETS] storage markets = marketsEntered[account];

        for (uint i = 1; i < numMarketsEntered; ++i) {
            if (markets[i] == underlying) return true;
        }

        return false;
    }

    function doEnterMarket(address account, address underlying) internal {
        AccountStorage storage accountStorage = accountLookup[account];

        uint32 numMarketsEntered = accountStorage.numMarketsEntered;
        address[MAX_POSSIBLE_ENTERED_MARKETS] storage markets = marketsEntered[account];

        if (numMarketsEntered != 0) {
            if (accountStorage.firstMarketEntered == underlying) return; // already entered
            for (uint i = 1; i < numMarketsEntered; i++) {
                if (markets[i] == underlying) return; // already entered
            }
        }

        require(numMarketsEntered < MAX_ENTERED_MARKETS, "e/too-many-entered-markets");

        if (numMarketsEntered == 0) accountStorage.firstMarketEntered = underlying;
        else markets[numMarketsEntered] = underlying;

        accountStorage.numMarketsEntered = numMarketsEntered + 1;

        emit EnterMarket(underlying, account);
    }

    // Liquidity check must be done by caller after calling this

    function doExitMarket(address account, address underlying) internal {
        AccountStorage storage accountStorage = accountLookup[account];

        uint32 numMarketsEntered = accountStorage.numMarketsEntered;
        address[MAX_POSSIBLE_ENTERED_MARKETS] storage markets = marketsEntered[account];
        uint searchIndex = type(uint).max;

        if (numMarketsEntered == 0) return; // already exited

        if (accountStorage.firstMarketEntered == underlying) {
            searchIndex = 0;
        } else {
            for (uint i = 1; i < numMarketsEntered; i++) {
                if (markets[i] == underlying) {
                    searchIndex = i;
                    break;
                }
            }

            if (searchIndex == type(uint).max) return; // already exited
        }

        uint lastMarketIndex = numMarketsEntered - 1;

        if (searchIndex != lastMarketIndex) {
            if (searchIndex == 0) accountStorage.firstMarketEntered = markets[lastMarketIndex];
            else markets[searchIndex] = markets[lastMarketIndex];
        }

        accountStorage.numMarketsEntered = uint32(lastMarketIndex);

        if (lastMarketIndex != 0) markets[lastMarketIndex] = address(0); // zero out for storage refund

        emit ExitMarket(underlying, account);
    }



    // AssetConfig

    function resolveAssetConfig(address underlying) internal view returns (AssetConfig memory) {
        AssetConfig memory config = underlyingLookup[underlying];
        require(config.eTokenAddress != address(0), "e/market-not-activated");

        if (config.borrowFactor == type(uint32).max) config.borrowFactor = DEFAULT_BORROW_FACTOR;
        if (config.twapWindow == type(uint24).max) config.twapWindow = DEFAULT_TWAP_WINDOW_SECONDS;

        return config;
    }


    // AssetCache

    struct AssetCache {
        address underlying;

        uint112 totalBalances;
        uint144 totalBorrows;

        uint96 reserveBalance;

        uint interestAccumulator;

        uint40 lastInterestAccumulatorUpdate;
        uint8 underlyingDecimals;
        uint32 interestRateModel;
        int96 interestRate;
        uint32 reserveFee;
        uint16 pricingType;
        uint32 pricingParameters;

        uint poolSize; // result of calling balanceOf on underlying (in external units)

        uint underlyingDecimalsScaler;
        uint maxExternalAmount;
    }

    function initAssetCache(address underlying, AssetStorage storage assetStorage, AssetCache memory assetCache) internal view returns (bool dirty) {
        dirty = false;

        assetCache.underlying = underlying;

        // Storage loads

        assetCache.lastInterestAccumulatorUpdate = assetStorage.lastInterestAccumulatorUpdate;
        uint8 underlyingDecimals = assetCache.underlyingDecimals = assetStorage.underlyingDecimals;
        assetCache.interestRateModel = assetStorage.interestRateModel;
        assetCache.interestRate = assetStorage.interestRate;
        assetCache.reserveFee = assetStorage.reserveFee;
        assetCache.pricingType = assetStorage.pricingType;
        assetCache.pricingParameters = assetStorage.pricingParameters;

        assetCache.reserveBalance = assetStorage.reserveBalance;

        assetCache.totalBalances = assetStorage.totalBalances;
        assetCache.totalBorrows = assetStorage.totalBorrows;

        assetCache.interestAccumulator = assetStorage.interestAccumulator;

        // Derived state

        unchecked {
            assetCache.underlyingDecimalsScaler = 10**(18 - underlyingDecimals);
            assetCache.maxExternalAmount = MAX_SANE_AMOUNT / assetCache.underlyingDecimalsScaler;
        }

        uint poolSize = callBalanceOf(assetCache, address(this));
        if (poolSize <= assetCache.maxExternalAmount) {
            unchecked { assetCache.poolSize = poolSize * assetCache.underlyingDecimalsScaler; }
        } else {
            assetCache.poolSize = 0;
        }

        // Update interest accumulator and reserves

        if (block.timestamp != assetCache.lastInterestAccumulatorUpdate) {
            dirty = true;

            uint deltaT = block.timestamp - assetCache.lastInterestAccumulatorUpdate;

            // Compute new values

            uint newInterestAccumulator = (RPow.rpow(uint(int(assetCache.interestRate) + 1e27), deltaT, 1e27) * assetCache.interestAccumulator) / 1e27;

            uint newTotalBorrows = assetCache.totalBorrows * newInterestAccumulator / assetCache.interestAccumulator;

            uint newReserveBalance = assetCache.reserveBalance;
            uint newTotalBalances = assetCache.totalBalances;

            uint feeAmount = (newTotalBorrows - assetCache.totalBorrows)
                               * (assetCache.reserveFee == type(uint32).max ? DEFAULT_RESERVE_FEE : assetCache.reserveFee)
                               / (RESERVE_FEE_SCALE * INTERNAL_DEBT_PRECISION);

            if (feeAmount != 0) {
                uint poolAssets = assetCache.poolSize + (newTotalBorrows / INTERNAL_DEBT_PRECISION);
                newTotalBalances = poolAssets * newTotalBalances / (poolAssets - feeAmount);
                newReserveBalance += newTotalBalances - assetCache.totalBalances;
            }

            // Store new values in assetCache, only if no overflows will occur

            if (newTotalBalances <= MAX_SANE_AMOUNT && newTotalBorrows <= MAX_SANE_DEBT_AMOUNT) {
                assetCache.totalBorrows = encodeDebtAmount(newTotalBorrows);
                assetCache.interestAccumulator = newInterestAccumulator;
                assetCache.lastInterestAccumulatorUpdate = uint40(block.timestamp);

                if (newTotalBalances != assetCache.totalBalances) {
                    assetCache.reserveBalance = encodeSmallAmount(newReserveBalance);
                    assetCache.totalBalances = encodeAmount(newTotalBalances);
                }
            }
        }
    }

    function loadAssetCache(address underlying, AssetStorage storage assetStorage) internal returns (AssetCache memory assetCache) {
        if (initAssetCache(underlying, assetStorage, assetCache)) {
            assetStorage.lastInterestAccumulatorUpdate = assetCache.lastInterestAccumulatorUpdate;

            assetStorage.underlying = assetCache.underlying; // avoid an SLOAD of this slot
            assetStorage.reserveBalance = assetCache.reserveBalance;

            assetStorage.totalBalances = assetCache.totalBalances;
            assetStorage.totalBorrows = assetCache.totalBorrows;

            assetStorage.interestAccumulator = assetCache.interestAccumulator;
        }
    }

    function loadAssetCacheRO(address underlying, AssetStorage storage assetStorage) internal view returns (AssetCache memory assetCache) {
        initAssetCache(underlying, assetStorage, assetCache);
    }



    // Utils

    function decodeExternalAmount(AssetCache memory assetCache, uint externalAmount) internal pure returns (uint scaledAmount) {
        require(externalAmount <= assetCache.maxExternalAmount, "e/amount-too-large");
        unchecked { scaledAmount = externalAmount * assetCache.underlyingDecimalsScaler; }
    }

    function encodeAmount(uint amount) internal pure returns (uint112) {
        require(amount <= MAX_SANE_AMOUNT, "e/amount-too-large-to-encode");
        return uint112(amount);
    }

    function encodeSmallAmount(uint amount) internal pure returns (uint96) {
        require(amount <= MAX_SANE_SMALL_AMOUNT, "e/small-amount-too-large-to-encode");
        return uint96(amount);
    }

    function encodeDebtAmount(uint amount) internal pure returns (uint144) {
        require(amount <= MAX_SANE_DEBT_AMOUNT, "e/debt-amount-too-large-to-encode");
        return uint144(amount);
    }

    function computeExchangeRate(AssetCache memory assetCache) private pure returns (uint) {
        if (assetCache.totalBalances == 0) return 1e18;
        return (assetCache.poolSize + (assetCache.totalBorrows / INTERNAL_DEBT_PRECISION)) * 1e18 / assetCache.totalBalances;
    }

    function underlyingAmountToBalance(AssetCache memory assetCache, uint amount) internal pure returns (uint) {
        uint exchangeRate = computeExchangeRate(assetCache);
        return amount * 1e18 / exchangeRate;
    }

    function underlyingAmountToBalanceRoundUp(AssetCache memory assetCache, uint amount) internal pure returns (uint) {
        uint exchangeRate = computeExchangeRate(assetCache);
        return (amount * 1e18 + (exchangeRate - 1)) / exchangeRate;
    }

    function balanceToUnderlyingAmount(AssetCache memory assetCache, uint amount) internal pure returns (uint) {
        uint exchangeRate = computeExchangeRate(assetCache);
        return amount * exchangeRate / 1e18;
    }

    function callBalanceOf(AssetCache memory assetCache, address account) internal view FREEMEM returns (uint) {
        // We set a gas limit so that a malicious token can't eat up all gas and cause a liquidity check to fail.

        (bool success, bytes memory data) = assetCache.underlying.staticcall{gas: 20000}(abi.encodeWithSelector(IERC20.balanceOf.selector, account));

        // If token's balanceOf() call fails for any reason, return 0. This prevents malicious tokens from causing liquidity checks to fail.
        // If the contract doesn't exist (maybe because selfdestructed), then data.length will be 0 and we will return 0.
        // Data length > 32 is allowed because some legitimate tokens append extra data that can be safely ignored.

        if (!success || data.length < 32) return 0;

        return abi.decode(data, (uint256));
    }

    function updateInterestRate(AssetStorage storage assetStorage, AssetCache memory assetCache) internal {
        uint32 utilisation;

        {
            uint totalBorrows = assetCache.totalBorrows / INTERNAL_DEBT_PRECISION;
            uint poolAssets = assetCache.poolSize + totalBorrows;
            if (poolAssets == 0) utilisation = 0; // empty pool arbitrarily given utilisation of 0
            else utilisation = uint32(totalBorrows * (uint(type(uint32).max) * 1e18) / poolAssets / 1e18);
        }

        bytes memory result = callInternalModule(assetCache.interestRateModel,
                                                 abi.encodeWithSelector(BaseIRM.computeInterestRate.selector, assetCache.underlying, utilisation));

        (int96 newInterestRate) = abi.decode(result, (int96));

        assetStorage.interestRate = assetCache.interestRate = newInterestRate;
    }

    function logAssetStatus(AssetCache memory a) internal {
        emit AssetStatus(a.underlying, a.totalBalances, a.totalBorrows / INTERNAL_DEBT_PRECISION, a.reserveBalance, a.poolSize, a.interestAccumulator, a.interestRate, block.timestamp);
    }



    // Balances

    function increaseBalance(AssetStorage storage assetStorage, AssetCache memory assetCache, address eTokenAddress, address account, uint amount) internal {
        assetStorage.users[account].balance = encodeAmount(assetStorage.users[account].balance + amount);

        assetStorage.totalBalances = assetCache.totalBalances = encodeAmount(uint(assetCache.totalBalances) + amount);

        updateInterestRate(assetStorage, assetCache);

        emit Deposit(assetCache.underlying, account, amount);
        emitViaProxy_Transfer(eTokenAddress, address(0), account, amount);
    }

    function decreaseBalance(AssetStorage storage assetStorage, AssetCache memory assetCache, address eTokenAddress, address account, uint amount) internal {
        uint origBalance = assetStorage.users[account].balance;
        require(origBalance >= amount, "e/insufficient-balance");
        assetStorage.users[account].balance = encodeAmount(origBalance - amount);

        assetStorage.totalBalances = assetCache.totalBalances = encodeAmount(assetCache.totalBalances - amount);

        updateInterestRate(assetStorage, assetCache);

        emit Withdraw(assetCache.underlying, account, amount);
        emitViaProxy_Transfer(eTokenAddress, account, address(0), amount);
    }

    function transferBalance(AssetStorage storage assetStorage, AssetCache memory assetCache, address eTokenAddress, address from, address to, uint amount) internal {
        uint origFromBalance = assetStorage.users[from].balance;
        require(origFromBalance >= amount, "e/insufficient-balance");
        uint newFromBalance;
        unchecked { newFromBalance = origFromBalance - amount; }

        assetStorage.users[from].balance = encodeAmount(newFromBalance);
        assetStorage.users[to].balance = encodeAmount(assetStorage.users[to].balance + amount);

        emit Withdraw(assetCache.underlying, from, amount);
        emit Deposit(assetCache.underlying, to, amount);
        emitViaProxy_Transfer(eTokenAddress, from, to, amount);
    }

    function withdrawAmounts(AssetStorage storage assetStorage, AssetCache memory assetCache, address account, uint amount) internal view returns (uint, uint) {
        uint amountInternal;
        if (amount == type(uint).max) {
            amountInternal = assetStorage.users[account].balance;
            amount = balanceToUnderlyingAmount(assetCache, amountInternal);
        } else {
            amount = decodeExternalAmount(assetCache, amount);
            amountInternal = underlyingAmountToBalanceRoundUp(assetCache, amount);
        }

        return (amount, amountInternal);
    }

    // Borrows

    // Returns internal precision

    function getCurrentOwedExact(AssetStorage storage assetStorage, AssetCache memory assetCache, address account, uint owed) internal view returns (uint) {
        // Don't bother loading the user's accumulator
        if (owed == 0) return 0;

        // Can't divide by 0 here: If owed is non-zero, we must've initialised the user's interestAccumulator
        return owed * assetCache.interestAccumulator / assetStorage.users[account].interestAccumulator;
    }

    // When non-zero, we round *up* to the smallest external unit so that outstanding dust in a loan can be repaid.
    // unchecked is OK here since owed is always loaded from storage, so we know it fits into a uint144 (pre-interest accural)
    // Takes and returns 27 decimals precision.

    function roundUpOwed(AssetCache memory assetCache, uint owed) private pure returns (uint) {
        if (owed == 0) return 0;

        unchecked {
            uint scale = INTERNAL_DEBT_PRECISION * assetCache.underlyingDecimalsScaler;
            return (owed + scale - 1) / scale * scale;
        }
    }

    // Returns 18-decimals precision (debt amount is rounded up)

    function getCurrentOwed(AssetStorage storage assetStorage, AssetCache memory assetCache, address account) internal view returns (uint) {
        return roundUpOwed(assetCache, getCurrentOwedExact(assetStorage, assetCache, account, assetStorage.users[account].owed)) / INTERNAL_DEBT_PRECISION;
    }

    function updateUserBorrow(AssetStorage storage assetStorage, AssetCache memory assetCache, address account) private returns (uint newOwedExact, uint prevOwedExact) {
        prevOwedExact = assetStorage.users[account].owed;

        newOwedExact = getCurrentOwedExact(assetStorage, assetCache, account, prevOwedExact);

        assetStorage.users[account].owed = encodeDebtAmount(newOwedExact);
        assetStorage.users[account].interestAccumulator = assetCache.interestAccumulator;
    }

    function logBorrowChange(AssetCache memory assetCache, address dTokenAddress, address account, uint prevOwed, uint owed) private {
        prevOwed = roundUpOwed(assetCache, prevOwed) / INTERNAL_DEBT_PRECISION;
        owed = roundUpOwed(assetCache, owed) / INTERNAL_DEBT_PRECISION;

        if (owed > prevOwed) {
            uint change = owed - prevOwed;
            emit Borrow(assetCache.underlying, account, change);
            emitViaProxy_Transfer(dTokenAddress, address(0), account, change);
        } else if (prevOwed > owed) {
            uint change = prevOwed - owed;
            emit Repay(assetCache.underlying, account, change);
            emitViaProxy_Transfer(dTokenAddress, account, address(0), change);
        }
    }

    function increaseBorrow(AssetStorage storage assetStorage, AssetCache memory assetCache, address dTokenAddress, address account, uint amount) internal {
        amount *= INTERNAL_DEBT_PRECISION;

        require(assetCache.pricingType != PRICINGTYPE__FORWARDED || pTokenLookup[assetCache.underlying] == address(0), "e/borrow-not-supported");

        (uint owed, uint prevOwed) = updateUserBorrow(assetStorage, assetCache, account);

        if (owed == 0) doEnterMarket(account, assetCache.underlying);

        owed += amount;

        assetStorage.users[account].owed = encodeDebtAmount(owed);
        assetStorage.totalBorrows = assetCache.totalBorrows = encodeDebtAmount(assetCache.totalBorrows + amount);

        updateInterestRate(assetStorage, assetCache);

        logBorrowChange(assetCache, dTokenAddress, account, prevOwed, owed);
    }

    function decreaseBorrow(AssetStorage storage assetStorage, AssetCache memory assetCache, address dTokenAddress, address account, uint origAmount) internal {
        uint amount = origAmount * INTERNAL_DEBT_PRECISION;

        (uint owed, uint prevOwed) = updateUserBorrow(assetStorage, assetCache, account);
        uint owedRoundedUp = roundUpOwed(assetCache, owed);

        require(amount <= owedRoundedUp, "e/repay-too-much");
        uint owedRemaining;
        unchecked { owedRemaining = owedRoundedUp - amount; }

        if (owed > assetCache.totalBorrows) owed = assetCache.totalBorrows;

        assetStorage.users[account].owed = encodeDebtAmount(owedRemaining);
        assetStorage.totalBorrows = assetCache.totalBorrows = encodeDebtAmount(assetCache.totalBorrows - owed + owedRemaining);

        updateInterestRate(assetStorage, assetCache);

        logBorrowChange(assetCache, dTokenAddress, account, prevOwed, owedRemaining);
    }

    function transferBorrow(AssetStorage storage assetStorage, AssetCache memory assetCache, address dTokenAddress, address from, address to, uint origAmount) internal {
        uint amount = origAmount * INTERNAL_DEBT_PRECISION;

        (uint fromOwed, uint fromOwedPrev) = updateUserBorrow(assetStorage, assetCache, from);
        (uint toOwed, uint toOwedPrev) = updateUserBorrow(assetStorage, assetCache, to);

        if (toOwed == 0) doEnterMarket(to, assetCache.underlying);

        // If amount was rounded up, transfer exact amount owed
        if (amount > fromOwed && amount - fromOwed < INTERNAL_DEBT_PRECISION) amount = fromOwed;

        require(fromOwed >= amount, "e/insufficient-balance");
        unchecked { fromOwed -= amount; }

        // Transfer any residual dust
        if (fromOwed < INTERNAL_DEBT_PRECISION) {
            amount += fromOwed;
            fromOwed = 0;
        }

        toOwed += amount;

        assetStorage.users[from].owed = encodeDebtAmount(fromOwed);
        assetStorage.users[to].owed = encodeDebtAmount(toOwed);

        logBorrowChange(assetCache, dTokenAddress, from, fromOwedPrev, fromOwed);
        logBorrowChange(assetCache, dTokenAddress, to, toOwedPrev, toOwed);
    }



    // Reserves

    function increaseReserves(AssetStorage storage assetStorage, AssetCache memory assetCache, uint amount) internal {
        assetStorage.reserveBalance = assetCache.reserveBalance = encodeSmallAmount(assetCache.reserveBalance + amount);
        assetStorage.totalBalances = assetCache.totalBalances = encodeAmount(assetCache.totalBalances + amount);
    }



    // Token asset transfers

    // amounts are in underlying units

    function pullTokens(AssetCache memory assetCache, address from, uint amount) internal returns (uint amountTransferred) {
        uint poolSizeBefore = assetCache.poolSize;

        Utils.safeTransferFrom(assetCache.underlying, from, address(this), amount / assetCache.underlyingDecimalsScaler);
        uint poolSizeAfter = assetCache.poolSize = decodeExternalAmount(assetCache, callBalanceOf(assetCache, address(this)));

        require(poolSizeAfter >= poolSizeBefore, "e/negative-transfer-amount");
        unchecked { amountTransferred = poolSizeAfter - poolSizeBefore; }
    }

    function pushTokens(AssetCache memory assetCache, address to, uint amount) internal returns (uint amountTransferred) {
        uint poolSizeBefore = assetCache.poolSize;

        Utils.safeTransfer(assetCache.underlying, to, amount / assetCache.underlyingDecimalsScaler);
        uint poolSizeAfter = assetCache.poolSize = decodeExternalAmount(assetCache, callBalanceOf(assetCache, address(this)));

        require(poolSizeBefore >= poolSizeAfter, "e/negative-transfer-amount");
        unchecked { amountTransferred = poolSizeBefore - poolSizeAfter; }
    }




    // Liquidity

    function getAssetPrice(address asset) internal returns (uint) {
        bytes memory result = callInternalModule(MODULEID__RISK_MANAGER, abi.encodeWithSelector(IRiskManager.getPrice.selector, asset));
        return abi.decode(result, (uint));
    }

    function getAccountLiquidity(address account) internal returns (uint collateralValue, uint liabilityValue) {
        bytes memory result = callInternalModule(MODULEID__RISK_MANAGER, abi.encodeWithSelector(IRiskManager.computeLiquidity.selector, account));
        (IRiskManager.LiquidityStatus memory status) = abi.decode(result, (IRiskManager.LiquidityStatus));

        collateralValue = status.collateralValue;
        liabilityValue = status.liabilityValue;
    }

    function checkLiquidity(address account) internal {
        uint8 status = accountLookup[account].deferLiquidityStatus;

        if (status == DEFERLIQUIDITY__NONE) {
            callInternalModule(MODULEID__RISK_MANAGER, abi.encodeWithSelector(IRiskManager.requireLiquidity.selector, account));
        } else if (status == DEFERLIQUIDITY__CLEAN) {
            accountLookup[account].deferLiquidityStatus = DEFERLIQUIDITY__DIRTY;
        }
    }



    // Optional average liquidity tracking

    function computeNewAverageLiquidity(address account, uint deltaT) private returns (uint) {
        uint currDuration = deltaT >= AVERAGE_LIQUIDITY_PERIOD ? AVERAGE_LIQUIDITY_PERIOD : deltaT;
        uint prevDuration = AVERAGE_LIQUIDITY_PERIOD - currDuration;

        uint currAverageLiquidity;

        {
            (uint collateralValue, uint liabilityValue) = getAccountLiquidity(account);
            currAverageLiquidity = collateralValue > liabilityValue ? collateralValue - liabilityValue : 0;
        }

        return (accountLookup[account].averageLiquidity * prevDuration / AVERAGE_LIQUIDITY_PERIOD) +
               (currAverageLiquidity * currDuration / AVERAGE_LIQUIDITY_PERIOD);
    }

    function getUpdatedAverageLiquidity(address account) internal returns (uint) {
        uint lastAverageLiquidityUpdate = accountLookup[account].lastAverageLiquidityUpdate;
        if (lastAverageLiquidityUpdate == 0) return 0;

        uint deltaT = block.timestamp - lastAverageLiquidityUpdate;
        if (deltaT == 0) return accountLookup[account].averageLiquidity;

        return computeNewAverageLiquidity(account, deltaT);
    }

    function getUpdatedAverageLiquidityWithDelegate(address account) internal returns (uint) {
        address delegate = accountLookup[account].averageLiquidityDelegate;

        return delegate != address(0) && accountLookup[delegate].averageLiquidityDelegate == account
            ? getUpdatedAverageLiquidity(delegate)
            : getUpdatedAverageLiquidity(account);
    }

    function updateAverageLiquidity(address account) internal {
        uint lastAverageLiquidityUpdate = accountLookup[account].lastAverageLiquidityUpdate;
        if (lastAverageLiquidityUpdate == 0) return;

        uint deltaT = block.timestamp - lastAverageLiquidityUpdate;
        if (deltaT == 0) return;

        accountLookup[account].lastAverageLiquidityUpdate = uint40(block.timestamp);
        accountLookup[account].averageLiquidity = computeNewAverageLiquidity(account, deltaT);
    }
}

File 3 of 13 : BaseModule.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Base.sol";


abstract contract BaseModule is Base {
    // Construction

    // public accessors common to all modules

    uint immutable public moduleId;
    bytes32 immutable public moduleGitCommit;

    constructor(uint moduleId_, bytes32 moduleGitCommit_) {
        moduleId = moduleId_;
        moduleGitCommit = moduleGitCommit_;
    }


    // Accessing parameters

    function unpackTrailingParamMsgSender() internal pure returns (address msgSender) {
        assembly {
            mstore(0, 0)

            calldatacopy(12, sub(calldatasize(), 40), 20)
            msgSender := mload(0)
        }
    }

    function unpackTrailingParams() internal pure returns (address msgSender, address proxyAddr) {
        assembly {
            mstore(0, 0)

            calldatacopy(12, sub(calldatasize(), 40), 20)
            msgSender := mload(0)

            calldatacopy(12, sub(calldatasize(), 20), 20)
            proxyAddr := mload(0)
        }
    }


    // Emit logs via proxies

    function emitViaProxy_Transfer(address proxyAddr, address from, address to, uint value) internal FREEMEM {
        (bool success,) = proxyAddr.call(abi.encodePacked(
                               uint8(3),
                               keccak256(bytes('Transfer(address,address,uint256)')),
                               bytes32(uint(uint160(from))),
                               bytes32(uint(uint160(to))),
                               value
                          ));
        require(success, "e/log-proxy-fail");
    }

    function emitViaProxy_Approval(address proxyAddr, address owner, address spender, uint value) internal FREEMEM {
        (bool success,) = proxyAddr.call(abi.encodePacked(
                               uint8(3),
                               keccak256(bytes('Approval(address,address,uint256)')),
                               bytes32(uint(uint160(owner))),
                               bytes32(uint(uint160(spender))),
                               value
                          ));
        require(success, "e/log-proxy-fail");
    }
}

File 4 of 13 : BaseIRM.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./BaseModule.sol";

abstract contract BaseIRM is BaseModule {
    constructor(uint moduleId_, bytes32 moduleGitCommit_) BaseModule(moduleId_, moduleGitCommit_) {}

    int96 internal constant MAX_ALLOWED_INTEREST_RATE = int96(int(uint(5 * 1e27) / SECONDS_PER_YEAR)); // 500% APR
    int96 internal constant MIN_ALLOWED_INTEREST_RATE = 0;

    function computeInterestRateImpl(address, uint32) internal virtual returns (int96);

    function computeInterestRate(address underlying, uint32 utilisation) external returns (int96) {
        int96 rate = computeInterestRateImpl(underlying, utilisation);

        if (rate > MAX_ALLOWED_INTEREST_RATE) rate = MAX_ALLOWED_INTEREST_RATE;
        else if (rate < MIN_ALLOWED_INTEREST_RATE) rate = MIN_ALLOWED_INTEREST_RATE;

        return rate;
    }

    function reset(address underlying, bytes calldata resetParams) external virtual {}
}

File 5 of 13 : Interfaces.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;


interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

interface IERC3156FlashBorrower {
    function onFlashLoan(address initiator, address token, uint256 amount, uint256 fee, bytes calldata data) external returns (bytes32);
}

interface IERC3156FlashLender {
    function maxFlashLoan(address token) external view returns (uint256);
    function flashFee(address token, uint256 amount) external view returns (uint256);
    function flashLoan(IERC3156FlashBorrower receiver, address token, uint256 amount, bytes calldata data) external returns (bool);
}

File 6 of 13 : Utils.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Interfaces.sol";

library Utils {
    function safeTransferFrom(address token, address from, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), string(data));
    }

    function safeTransfer(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), string(data));
    }

    function safeApprove(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), string(data));
    }
}

File 7 of 13 : RPow.sol
// SPDX-License-Identifier: AGPL-3.0-or-later

// From MakerDAO DSS

// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

library RPow {
    function rpow(uint x, uint n, uint base) internal pure returns (uint z) {
        assembly {
            switch x case 0 {switch n case 0 {z := base} default {z := 0}}
            default {
                switch mod(n, 2) case 0 { z := base } default { z := x }
                let half := div(base, 2)  // for rounding.
                for { n := div(n, 2) } n { n := div(n,2) } {
                    let xx := mul(x, x)
                    if iszero(eq(div(xx, x), x)) { revert(0,0) }
                    let xxRound := add(xx, half)
                    if lt(xxRound, xx) { revert(0,0) }
                    x := div(xxRound, base)
                    if mod(n,2) {
                        let zx := mul(z, x)
                        if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) }
                        let zxRound := add(zx, half)
                        if lt(zxRound, zx) { revert(0,0) }
                        z := div(zxRound, base)
                    }
                }
            }
        }
    }
}

File 8 of 13 : IRiskManager.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Storage.sol";

// This interface is used to avoid a circular dependency between BaseLogic and RiskManager

interface IRiskManager {
    struct NewMarketParameters {
        uint16 pricingType;
        uint32 pricingParameters;

        Storage.AssetConfig config;
    }

    struct LiquidityStatus {
        uint collateralValue;
        uint liabilityValue;
        uint numBorrows;
        bool borrowIsolated;
    }

    struct AssetLiquidity {
        address underlying;
        LiquidityStatus status;
    }

    function getNewMarketParameters(address underlying) external returns (NewMarketParameters memory);

    function requireLiquidity(address account) external;
    function computeLiquidity(address account) external returns (LiquidityStatus memory status);
    function computeAssetLiquidities(address account) external returns (AssetLiquidity[] memory assets);

    function getPrice(address underlying) external returns (uint twap, uint twapPeriod);
    function getPriceFull(address underlying) external returns (uint twap, uint twapPeriod, uint currPrice);
}

File 9 of 13 : Base.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;
//import "hardhat/console.sol"; // DEV_MODE

import "./Storage.sol";
import "./Events.sol";
import "./Proxy.sol";

abstract contract Base is Storage, Events {
    // Modules

    function _createProxy(uint proxyModuleId) internal returns (address) {
        require(proxyModuleId != 0, "e/create-proxy/invalid-module");
        require(proxyModuleId <= MAX_EXTERNAL_MODULEID, "e/create-proxy/internal-module");

        // If we've already created a proxy for a single-proxy module, just return it:

        if (proxyLookup[proxyModuleId] != address(0)) return proxyLookup[proxyModuleId];

        // Otherwise create a proxy:

        address proxyAddr = address(new Proxy());

        if (proxyModuleId <= MAX_EXTERNAL_SINGLE_PROXY_MODULEID) proxyLookup[proxyModuleId] = proxyAddr;

        trustedSenders[proxyAddr] = TrustedSenderInfo({ moduleId: uint32(proxyModuleId), moduleImpl: address(0) });

        emit ProxyCreated(proxyAddr, proxyModuleId);

        return proxyAddr;
    }

    function callInternalModule(uint moduleId, bytes memory input) internal returns (bytes memory) {
        (bool success, bytes memory result) = moduleLookup[moduleId].delegatecall(input);
        if (!success) revertBytes(result);
        return result;
    }



    // Modifiers

    modifier nonReentrant() {
        require(reentrancyLock == REENTRANCYLOCK__UNLOCKED, "e/reentrancy");

        reentrancyLock = REENTRANCYLOCK__LOCKED;
        _;
        reentrancyLock = REENTRANCYLOCK__UNLOCKED;
    }

    modifier reentrantOK() { // documentation only
        _;
    }

    // WARNING: Must be very careful with this modifier. It resets the free memory pointer
    // to the value it was when the function started. This saves gas if more memory will
    // be allocated in the future. However, if the memory will be later referenced
    // (for example because the function has returned a pointer to it) then you cannot
    // use this modifier.

    modifier FREEMEM() {
        uint origFreeMemPtr;

        assembly {
            origFreeMemPtr := mload(0x40)
        }

        _;

        /*
        assembly { // DEV_MODE: overwrite the freed memory with garbage to detect bugs
            let garbage := 0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF
            for { let i := origFreeMemPtr } lt(i, mload(0x40)) { i := add(i, 32) } { mstore(i, garbage) }
        }
        */

        assembly {
            mstore(0x40, origFreeMemPtr)
        }
    }



    // Error handling

    function revertBytes(bytes memory errMsg) internal pure {
        if (errMsg.length > 0) {
            assembly {
                revert(add(32, errMsg), mload(errMsg))
            }
        }

        revert("e/empty-error");
    }
}

File 10 of 13 : Storage.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Constants.sol";

abstract contract Storage is Constants {
    // Dispatcher and upgrades

    uint reentrancyLock;

    address upgradeAdmin;
    address governorAdmin;

    mapping(uint => address) moduleLookup; // moduleId => module implementation
    mapping(uint => address) proxyLookup; // moduleId => proxy address (only for single-proxy modules)

    struct TrustedSenderInfo {
        uint32 moduleId; // 0 = un-trusted
        address moduleImpl; // only non-zero for external single-proxy modules
    }

    mapping(address => TrustedSenderInfo) trustedSenders; // sender address => moduleId (0 = un-trusted)



    // Account-level state
    // Sub-accounts are considered distinct accounts

    struct AccountStorage {
        // Packed slot: 1 + 5 + 4 + 20 = 30
        uint8 deferLiquidityStatus;
        uint40 lastAverageLiquidityUpdate;
        uint32 numMarketsEntered;
        address firstMarketEntered;

        uint averageLiquidity;
        address averageLiquidityDelegate;
    }

    mapping(address => AccountStorage) accountLookup;
    mapping(address => address[MAX_POSSIBLE_ENTERED_MARKETS]) marketsEntered;



    // Markets and assets

    struct AssetConfig {
        // Packed slot: 20 + 1 + 4 + 4 + 3 = 32
        address eTokenAddress;
        bool borrowIsolated;
        uint32 collateralFactor;
        uint32 borrowFactor;
        uint24 twapWindow;
    }

    struct UserAsset {
        uint112 balance;
        uint144 owed;

        uint interestAccumulator;
    }

    struct AssetStorage {
        // Packed slot: 5 + 1 + 4 + 12 + 4 + 2 + 4 = 32
        uint40 lastInterestAccumulatorUpdate;
        uint8 underlyingDecimals; // Not dynamic, but put here to live in same storage slot
        uint32 interestRateModel;
        int96 interestRate;
        uint32 reserveFee;
        uint16 pricingType;
        uint32 pricingParameters;

        address underlying;
        uint96 reserveBalance;

        address dTokenAddress;

        uint112 totalBalances;
        uint144 totalBorrows;

        uint interestAccumulator;

        mapping(address => UserAsset) users;

        mapping(address => mapping(address => uint)) eTokenAllowance;
        mapping(address => mapping(address => uint)) dTokenAllowance;
    }

    mapping(address => AssetConfig) internal underlyingLookup; // underlying => AssetConfig
    mapping(address => AssetStorage) internal eTokenLookup; // EToken => AssetStorage
    mapping(address => address) internal dTokenLookup; // DToken => EToken
    mapping(address => address) internal pTokenLookup; // PToken => underlying
    mapping(address => address) internal reversePTokenLookup; // underlying => PToken
}

File 11 of 13 : Events.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Storage.sol";

abstract contract Events {
    event Genesis();


    event ProxyCreated(address indexed proxy, uint moduleId);
    event MarketActivated(address indexed underlying, address indexed eToken, address indexed dToken);
    event PTokenActivated(address indexed underlying, address indexed pToken);

    event EnterMarket(address indexed underlying, address indexed account);
    event ExitMarket(address indexed underlying, address indexed account);

    event Deposit(address indexed underlying, address indexed account, uint amount);
    event Withdraw(address indexed underlying, address indexed account, uint amount);
    event Borrow(address indexed underlying, address indexed account, uint amount);
    event Repay(address indexed underlying, address indexed account, uint amount);

    event Liquidation(address indexed liquidator, address indexed violator, address indexed underlying, address collateral, uint repay, uint yield, uint healthScore, uint baseDiscount, uint discount);

    event TrackAverageLiquidity(address indexed account);
    event UnTrackAverageLiquidity(address indexed account);
    event DelegateAverageLiquidity(address indexed account, address indexed delegate);

    event PTokenWrap(address indexed underlying, address indexed account, uint amount);
    event PTokenUnWrap(address indexed underlying, address indexed account, uint amount);

    event AssetStatus(address indexed underlying, uint totalBalances, uint totalBorrows, uint96 reserveBalance, uint poolSize, uint interestAccumulator, int96 interestRate, uint timestamp);


    event RequestDeposit(address indexed account, uint amount);
    event RequestWithdraw(address indexed account, uint amount);
    event RequestMint(address indexed account, uint amount);
    event RequestBurn(address indexed account, uint amount);
    event RequestTransferEToken(address indexed from, address indexed to, uint amount);

    event RequestBorrow(address indexed account, uint amount);
    event RequestRepay(address indexed account, uint amount);
    event RequestTransferDToken(address indexed from, address indexed to, uint amount);

    event RequestLiquidate(address indexed liquidator, address indexed violator, address indexed underlying, address collateral, uint repay, uint minYield);


    event InstallerSetUpgradeAdmin(address indexed newUpgradeAdmin);
    event InstallerSetGovernorAdmin(address indexed newGovernorAdmin);
    event InstallerInstallModule(uint indexed moduleId, address indexed moduleImpl, bytes32 moduleGitCommit);


    event GovSetAssetConfig(address indexed underlying, Storage.AssetConfig newConfig);
    event GovSetIRM(address indexed underlying, uint interestRateModel, bytes resetParams);
    event GovSetPricingConfig(address indexed underlying, uint16 newPricingType, uint32 newPricingParameter);
    event GovSetReserveFee(address indexed underlying, uint32 newReserveFee);
    event GovConvertReserves(address indexed underlying, address indexed recipient, uint amount);

    event RequestSwap(address indexed accountIn, address indexed accountOut, address indexed underlyingIn, address underlyingOut, uint amount, uint swapType);
}

File 12 of 13 : Proxy.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

contract Proxy {
    address immutable creator;

    constructor() {
        creator = msg.sender;
    }

    // External interface

    fallback() external {
        address creator_ = creator;

        if (msg.sender == creator_) {
            assembly {
                mstore(0, 0)
                calldatacopy(31, 0, calldatasize())

                switch mload(0) // numTopics
                    case 0 { log0(32,  sub(calldatasize(), 1)) }
                    case 1 { log1(64,  sub(calldatasize(), 33),  mload(32)) }
                    case 2 { log2(96,  sub(calldatasize(), 65),  mload(32), mload(64)) }
                    case 3 { log3(128, sub(calldatasize(), 97),  mload(32), mload(64), mload(96)) }
                    case 4 { log4(160, sub(calldatasize(), 129), mload(32), mload(64), mload(96), mload(128)) }
                    default { revert(0, 0) }

                return(0, 0)
            }
        } else {
            assembly {
                mstore(0, 0xe9c4a3ac00000000000000000000000000000000000000000000000000000000) // dispatch() selector
                calldatacopy(4, 0, calldatasize())
                mstore(add(4, calldatasize()), shl(96, caller()))

                let result := call(gas(), creator_, 0, 0, add(24, calldatasize()), 0, 0)
                returndatacopy(0, 0, returndatasize())

                switch result
                    case 0 { revert(0, returndatasize()) }
                    default { return(0, returndatasize()) }
            }
        }
    }
}

File 13 of 13 : Constants.sol
// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

abstract contract Constants {
    // Universal

    uint internal constant SECONDS_PER_YEAR = 365.2425 * 86400; // Gregorian calendar


    // Protocol parameters

    uint internal constant MAX_SANE_AMOUNT = type(uint112).max;
    uint internal constant MAX_SANE_SMALL_AMOUNT = type(uint96).max;
    uint internal constant MAX_SANE_DEBT_AMOUNT = type(uint144).max;
    uint internal constant INTERNAL_DEBT_PRECISION = 1e9;
    uint internal constant MAX_ENTERED_MARKETS = 10; // per sub-account
    uint internal constant MAX_POSSIBLE_ENTERED_MARKETS = 2**32; // limited by size of AccountStorage.numMarketsEntered
    uint internal constant CONFIG_FACTOR_SCALE = 4_000_000_000; // must fit into a uint32
    uint internal constant RESERVE_FEE_SCALE = 4_000_000_000; // must fit into a uint32
    uint32 internal constant DEFAULT_RESERVE_FEE = uint32(0.23 * 4_000_000_000);
    uint internal constant INITIAL_INTEREST_ACCUMULATOR = 1e27;
    uint internal constant AVERAGE_LIQUIDITY_PERIOD = 24 * 60 * 60;
    uint16 internal constant MIN_UNISWAP3_OBSERVATION_CARDINALITY = 10;
    uint24 internal constant DEFAULT_TWAP_WINDOW_SECONDS = 30 * 60;
    uint32 internal constant DEFAULT_BORROW_FACTOR = uint32(0.28 * 4_000_000_000);


    // Implementation internals

    uint internal constant REENTRANCYLOCK__UNLOCKED = 1;
    uint internal constant REENTRANCYLOCK__LOCKED = 2;

    uint8 internal constant DEFERLIQUIDITY__NONE = 0;
    uint8 internal constant DEFERLIQUIDITY__CLEAN = 1;
    uint8 internal constant DEFERLIQUIDITY__DIRTY = 2;


    // Pricing types

    uint16 internal constant PRICINGTYPE__PEGGED = 1;
    uint16 internal constant PRICINGTYPE__UNISWAP3_TWAP = 2;
    uint16 internal constant PRICINGTYPE__FORWARDED = 3;


    // Modules

    // Public single-proxy modules
    uint internal constant MODULEID__INSTALLER = 1;
    uint internal constant MODULEID__MARKETS = 2;
    uint internal constant MODULEID__LIQUIDATION = 3;
    uint internal constant MODULEID__GOVERNANCE = 4;
    uint internal constant MODULEID__EXEC = 5;
    uint internal constant MODULEID__SWAP = 6;

    uint internal constant MAX_EXTERNAL_SINGLE_PROXY_MODULEID = 499_999;

    // Public multi-proxy modules
    uint internal constant MODULEID__ETOKEN = 500_000;
    uint internal constant MODULEID__DTOKEN = 500_001;

    uint internal constant MAX_EXTERNAL_MODULEID = 999_999;

    // Internal modules
    uint internal constant MODULEID__RISK_MANAGER = 1_000_000;

    // Interest rate models
    //   Default for new markets
    uint internal constant MODULEID__IRM_DEFAULT = 2_000_000;
    //   Testing-only
    uint internal constant MODULEID__IRM_ZERO = 2_000_001;
    uint internal constant MODULEID__IRM_FIXED = 2_000_002;
    uint internal constant MODULEID__IRM_LINEAR = 2_000_100;
    //   Classes
    uint internal constant MODULEID__IRM_CLASS__STABLE = 2_000_500;
    uint internal constant MODULEID__IRM_CLASS__MAJOR = 2_000_501;
    uint internal constant MODULEID__IRM_CLASS__MIDCAP = 2_000_502;

    // Swap types
    uint internal constant SWAP_TYPE__UNI_EXACT_INPUT_SINGLE = 1;
    uint internal constant SWAP_TYPE__UNI_EXACT_INPUT = 2;
    uint internal constant SWAP_TYPE__UNI_EXACT_OUTPUT_SINGLE = 3;
    uint internal constant SWAP_TYPE__UNI_EXACT_OUTPUT = 4;
    uint internal constant SWAP_TYPE__1INCH = 5;
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"bytes32","name":"moduleGitCommit_","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalBalances","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalBorrows","type":"uint256"},{"indexed":false,"internalType":"uint96","name":"reserveBalance","type":"uint96"},{"indexed":false,"internalType":"uint256","name":"poolSize","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"interestAccumulator","type":"uint256"},{"indexed":false,"internalType":"int96","name":"interestRate","type":"int96"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AssetStatus","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Borrow","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"delegate","type":"address"}],"name":"DelegateAverageLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"EnterMarket","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"ExitMarket","type":"event"},{"anonymous":false,"inputs":[],"name":"Genesis","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"GovConvertReserves","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"components":[{"internalType":"address","name":"eTokenAddress","type":"address"},{"internalType":"bool","name":"borrowIsolated","type":"bool"},{"internalType":"uint32","name":"collateralFactor","type":"uint32"},{"internalType":"uint32","name":"borrowFactor","type":"uint32"},{"internalType":"uint24","name":"twapWindow","type":"uint24"}],"indexed":false,"internalType":"struct Storage.AssetConfig","name":"newConfig","type":"tuple"}],"name":"GovSetAssetConfig","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"uint256","name":"interestRateModel","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"resetParams","type":"bytes"}],"name":"GovSetIRM","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"uint16","name":"newPricingType","type":"uint16"},{"indexed":false,"internalType":"uint32","name":"newPricingParameter","type":"uint32"}],"name":"GovSetPricingConfig","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"uint32","name":"newReserveFee","type":"uint32"}],"name":"GovSetReserveFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"moduleId","type":"uint256"},{"indexed":true,"internalType":"address","name":"moduleImpl","type":"address"},{"indexed":false,"internalType":"bytes32","name":"moduleGitCommit","type":"bytes32"}],"name":"InstallerInstallModule","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newGovernorAdmin","type":"address"}],"name":"InstallerSetGovernorAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newUpgradeAdmin","type":"address"}],"name":"InstallerSetUpgradeAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"liquidator","type":"address"},{"indexed":true,"internalType":"address","name":"violator","type":"address"},{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"address","name":"collateral","type":"address"},{"indexed":false,"internalType":"uint256","name":"repay","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"yield","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"healthScore","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"baseDiscount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"discount","type":"uint256"}],"name":"Liquidation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"eToken","type":"address"},{"indexed":true,"internalType":"address","name":"dToken","type":"address"}],"name":"MarketActivated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"pToken","type":"address"}],"name":"PTokenActivated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PTokenUnWrap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PTokenWrap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"uint256","name":"moduleId","type":"uint256"}],"name":"ProxyCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Repay","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestBorrow","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestBurn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"liquidator","type":"address"},{"indexed":true,"internalType":"address","name":"violator","type":"address"},{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"address","name":"collateral","type":"address"},{"indexed":false,"internalType":"uint256","name":"repay","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"minYield","type":"uint256"}],"name":"RequestLiquidate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestRepay","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"accountIn","type":"address"},{"indexed":true,"internalType":"address","name":"accountOut","type":"address"},{"indexed":true,"internalType":"address","name":"underlyingIn","type":"address"},{"indexed":false,"internalType":"address","name":"underlyingOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"swapType","type":"uint256"}],"name":"RequestSwap","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":"amount","type":"uint256"}],"name":"RequestTransferDToken","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":"amount","type":"uint256"}],"name":"RequestTransferEToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"TrackAverageLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"UnTrackAverageLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"DISCOUNT_BOOSTER_SLOPE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_BOOSTER_DISCOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_DISCOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TARGET_HEALTH","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNDERLYING_RESERVES_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"violator","type":"address"},{"internalType":"address","name":"underlying","type":"address"},{"internalType":"address","name":"collateral","type":"address"}],"name":"checkLiquidation","outputs":[{"components":[{"internalType":"uint256","name":"repay","type":"uint256"},{"internalType":"uint256","name":"yield","type":"uint256"},{"internalType":"uint256","name":"healthScore","type":"uint256"},{"internalType":"uint256","name":"baseDiscount","type":"uint256"},{"internalType":"uint256","name":"discount","type":"uint256"},{"internalType":"uint256","name":"conversionRate","type":"uint256"}],"internalType":"struct Liquidation.LiquidationOpportunity","name":"liqOpp","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"violator","type":"address"},{"internalType":"address","name":"underlying","type":"address"},{"internalType":"address","name":"collateral","type":"address"},{"internalType":"uint256","name":"repay","type":"uint256"},{"internalType":"uint256","name":"minYield","type":"uint256"}],"name":"liquidate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"moduleGitCommit","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"moduleId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000df359cfaa399c01a62b1f64767460715eb7df4d3

-----Decoded View---------------
Arg [0] : moduleGitCommit_ (bytes32): 0x000000000000000000000000df359cfaa399c01a62b1f64767460715eb7df4d3

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000df359cfaa399c01a62b1f64767460715eb7df4d3


Deployed ByteCode Sourcemap

171:11831:11:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7219:448;;;;;;:::i;:::-;;:::i;:::-;;;;;;801:4:13;843:3;832:9;828:19;820:27;;880:6;874:13;863:9;856:32;944:4;936:6;932:17;926:24;919:4;908:9;904:20;897:54;1007:4;999:6;995:17;989:24;982:4;971:9;967:20;960:54;1070:4;1062:6;1058:17;1052:24;1045:4;1034:9;1030:20;1023:54;1133:4;1125:6;1121:17;1115:24;1108:4;1097:9;1093:20;1086:54;1196:4;1188:6;1184:17;1178:24;1171:4;1160:9;1156:20;1149:54;629:580;;;;;7219:448:11;;;;;;;;383:58;;430:11;383:58;;;;;1360:25:13;;;1348:2;1333:18;383:58:11;1214:177:13;514:51:11;;554:11;514:51;;241:40:3;;;;;8161:795:11;;;;;;:::i;:::-;;:::i;:::-;;767:54;;813:8;767:54;;205:30:3;;;;;902:60:11;;950:12;902:60;;1066:48;;1103:11;1066:48;;7219:448;7354:36;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7354:36:11;1390:1:4;1389:14:0;;:42;1381:67;;;;;;;2257:2:13;1381:67:0;;;2239:21:13;2296:2;2276:18;;;2269:30;2335:14;2315:18;;;2308:42;2367:18;;1381:67:0;;;;;;;;;1445:1:4;1459:14:0;:39;7402:32:11::1;;:::i;:::-;7445:31;::::0;;::::1;::::0;;7486:27;;::::1;:16;::::0;::::1;:27:::0;7523:31;;::::1;:18;::::0;::::1;:31:::0;7564;::::1;:18;::::0;::::1;:31:::0;7606:22:::1;7445:7:::0;7606:13:::1;:22::i;:::-;7646:14;;::::0;1390:1:4;1519:14:0;:41;7646:14:11;7219:448;-1:-1:-1;;;;;7219:448:11:o;8161:795::-;1390:1:4;1389:14:0;;:42;1381:67;;;;;;;2257:2:13;1381:67:0;;;2239:21:13;2296:2;2276:18;;;2269:30;2335:14;2315:18;;;2308:42;2367:18;;1381:67:0;2055:336:13;1381:67:0;1445:1:4;1459:14:0;:39;;;8305:23:11::1;::::0;::::1;::::0;;:13:::1;:23;::::0;;;;:44;:68:::1;:44;:68:::0;8297:114:::1;;;::::0;::::1;::::0;;2598:2:13;8297:114:11::1;::::0;::::1;2580:21:13::0;2637:2;2617:18;;;2610:30;2676:34;2656:18;;;2649:62;2747:3;2727:18;;;2720:31;2768:19;;8297:114:11::1;2396:397:13::0;8297:114:11::1;8422:18;8443:30;:28;:30::i;:::-;8489:79;::::0;;::::1;3018:55:13::0;;;3000:74;;3105:2;3090:18;;3083:34;;;3133:18;;;3126:34;;;8422:51:11;;-1:-1:-1;8489:79:11;;::::1;::::0;;;::::1;::::0;;::::1;::::0;::::1;::::0;2988:2:13;2973:18;8489:79:11::1;;;;;;;8579:34;8602:10;8579:22;:34::i;:::-;8623:32;8646:8;8623:22;:32::i;:::-;8667;;:::i;:::-;8710:31;::::0;;::::1;::::0;;8751:27;;::::1;:16;::::0;::::1;:27:::0;8788:31;;::::1;:18;::::0;::::1;:31:::0;8829;::::1;:18;::::0;::::1;:31:::0;8871:22:::1;8710:7:::0;8871:13:::1;:22::i;:::-;8905:44;8924:7;8933:5;8940:8;8905:18;:44::i;:::-;-1:-1:-1::0;;1390:1:4;1519:14:0;:41;-1:-1:-1;;;;;8161:795:11:o;1700:4622::-;1784:52;1799:7;:16;;;1817:7;:18;;;1784:14;:52::i;:::-;1783:53;1775:88;;;;;;;3373:2:13;1775:88:11;;;3355:21:13;3412:2;3392:18;;;3385:30;3451:24;3431:18;;;3424:52;3493:18;;1775:88:11;3171:346:13;1775:88:11;1881:55;1899:7;:16;;;1917:7;:18;;;1881:17;:55::i;:::-;1873:105;;;;;;;3724:2:13;1873:105:11;;;3706:21:13;3763:2;3743:18;;;3736:30;3802:34;3782:18;;;3775:62;3873:7;3853:18;;;3846:35;3898:19;;1873:105:11;3522:401:13;1873:105:11;1996:55;2014:7;:16;;;2032:7;:18;;;1996:17;:55::i;:::-;1988:105;;;;;;;4130:2:13;1988:105:11;;;4112:21:13;4169:2;4149:18;;;4142:30;4208:34;4188:18;;;4181:62;4279:7;4259:18;;;4252:35;4304:19;;1988:105:11;3928:401:13;1988:105:11;2130:33;2144:7;:18;;;2130:13;:33::i;:::-;2104:23;;;:59;2213:18;;;;2199:33;;:13;:33::i;:::-;2173:23;;;:59;2282:14;;;;2383:18;;;;;;2366:36;;;;2243;2366;;;:16;:36;;;;;;;:50;;;;2353:64;;:12;:64;;;;;;2483:18;;2353:64;;2243:36;2468:58;;2353:64;2468:14;:58::i;:::-;2613:18;;;;;2596:36;;;;2537:43;2596:36;;;:16;:36;;;;;;;;:50;;;;2583:64;;:12;:64;;;;;2713:18;;2427:99;;-1:-1:-1;2583:64:11;;2698:58;;2583:64;2698:14;:58::i;:::-;2797:1;2782:12;;;;:16;;;2767:31;;;2875:16;;;2657:99;;-1:-1:-1;2797:1:11;;;2855:37;;:19;:37::i;:::-;2809:83;;;;2907:14;2925:1;2907:19;2903:121;;;-1:-1:-1;;2963:14:11;2942:18;;;;:35;;;;-1:-1:-1;;;;;1700:4622:11:o;2903:121::-;3080:14;3055:22;:15;3073:4;3055:22;:::i;:::-;:39;;;;:::i;:::-;3034:18;;;:60;3109:33;;;3105:86;;3158:7;;;;;;;1700:4622;:::o;3105:86::-;3323:17;3377:6;:18;;;3370:4;:25;;;;:::i;:::-;3343:53;;430:11;3343:53;:::i;:::-;3323:73;;3411:20;3434:58;3457:7;:18;;;3477:14;3434:22;:58::i;:::-;3411:81;-1:-1:-1;3507:13:11;3556:4;3523:30;3411:81;3523:12;:30;:::i;:::-;:37;;;;:::i;:::-;3507:53;-1:-1:-1;3591:39:11;950:12;3591;:39;:::i;:::-;3579:8;:52;3575:108;;;3644:39;950:12;3644;:39;:::i;:::-;3633:50;;3575:108;554:11;3701:8;:27;3697:60;;;-1:-1:-1;554:11:11;3697:60;3772:19;;;:34;;;3820:15;;;:26;;;3951:15;3838:8;3951:4;:15;:::i;:::-;3917:23;;;;3884;;;;:30;;3910:4;3884:30;:::i;:::-;:56;;;;:::i;:::-;:63;;3943:4;3884:63;:::i;:::-;:83;;;;:::i;:::-;3860:21;;;:107;-1:-1:-1;;;4114:18:11;;;;4057:35;;4095:38;;:18;:38::i;:::-;4057:76;;4143:35;4181:38;4200:7;:18;;;4181;:38::i;:::-;4143:76;-1:-1:-1;4244:25:11;4305:4;4272:30;1103:11;4272:14;:30;:::i;:::-;:37;;;;:::i;:::-;4244:65;;4468:14;4523:16;:29;;;4485:67;;736:13:4;1103:11:11;4485:35;;;;:::i;:::-;:67;;;;:::i;:::-;4468:84;;4566:18;4673:6;:15;;;4666:4;:22;;;;:::i;:::-;736:13:4;4599:16:11;:33;;;4594:39;;4587:4;:46;;;;:::i;:::-;:68;;;;:::i;:::-;:75;;4658:4;4587:75;:::i;:::-;:102;;;;:::i;:::-;4566:123;;4721:13;4708:9;:26;4704:398;;4769:14;4754:29;;4704:398;;;4898:24;4976:25;4988:13;4976:9;:25;:::i;:::-;4926:38;4949:15;4926:20;:38;:::i;:::-;4925:47;;4968:4;4925:47;:::i;:::-;:77;;;;:::i;:::-;5064:23;;;;4898:104;;-1:-1:-1;5035:26:11;4898:104;5057:4;5035:26;:::i;:::-;:52;;;;:::i;:::-;5020:67;;-1:-1:-1;4704:398:11;4230:882;;;5302:16;5321:78;5336:22;5360:20;5382:7;:16;;;5321:14;:78::i;:::-;5302:97;;5432:11;5417:6;:12;;;:26;5413:58;;;5445:26;;;5413:58;-1:-1:-1;5748:21:11;;;;5733:12;;5772:4;;5733:36;;;:::i;:::-;:43;;;;:::i;:::-;5718:12;;;;:58;;;;5903:16;;;;5874:46;;5801:22;5874:46;;;:28;;;:46;;;;;;:54;5826:103;;5852:20;;5874:54;;5826:25;:103::i;:::-;5801:128;;5968:6;:12;;;5948:17;:32;5944:184;;;6042:21;;;;6015:24;:17;6035:4;6015:24;:::i;:::-;:48;;;;:::i;:::-;6000:63;;6081:12;;;:32;;;5944:184;-1:-1:-1;6224:12:11;;6201:20;;;:35;6311:4;6277:30;430:11;6311:4;6277:30;:::i;:::-;6261:12;;:47;;;;:::i;:::-;:54;;;;:::i;:::-;6246:69;;;-1:-1:-1;;;;;;;;;1700:4622:11:o;459:236:3:-;522:17;584:1;581;574:12;642:2;637;621:14;617:23;613:2;600:45;-1:-1:-1;677:1:3;671:8;;459:236::o;26640:494:2:-;26742:22;;;26708:31;26742:22;;;:13;:22;;;;;:49;;;;;;;26801:44;;26838:7;26640:494;:::o;26801:44::-;26855:11;26869:44;26887:26;26869:15;:44;:::i;:::-;26855:58;-1:-1:-1;26927:11:2;26923:24;;26940:7;;26640:494;:::o;26923:24::-;26957:22;;;;;;;:13;:22;;;;;:75;;;;;27016:15;26957:75;;;;;;27084:43;26957:22;27120:6;27084:26;:43::i;:::-;27042:22;;;;;;;;:13;:22;;;;;:39;;:85;;;;-1:-1:-1;;26640:494:2:o;8962:2731:11:-;9100:14;;;;:20;9084:36;;;9076:77;;;;;;;5689:2:13;9076:77:11;;;5671:21:13;5728:2;5708:18;;;5701:30;5767;5747:18;;;5740:58;5815:18;;9076:77:11;5487:352:13;9076:77:11;9276:18;;;;;;9259:36;;;;9165:10;9259:36;;;:16;:36;;;;;;;:50;;;;9246:64;;:12;:64;;;;;;9380:18;;9165:10;;9365:58;;9246:64;9365:14;:58::i;:::-;9458:14;;;;:20;9324:99;;-1:-1:-1;9442:36:11;;9438:167;;;9488:7;:20;;;9480:28;;9438:167;;;9601:4;9566:30;430:11;9601:4;9566:30;:::i;:::-;9551:46;;:11;:46;:::i;:::-;9535:63;;:12;:63;:::i;:::-;:70;;;;:::i;:::-;9527:78;;9438:167;9638:15;9656:20;9671:5;9656:12;:20;:::i;:::-;9813:36;;;;9851:16;;;;9869:18;;9638:38;;-1:-1:-1;9752:143:11;;9767:22;;9791:20;;9813:36;;;;;9889:5;9752:14;:143::i;:::-;10044:36;;;;10082:18;;9983:130;;9998:22;;10022:20;;10044:36;;;10102:10;9983:14;:130::i;:::-;10246:15;490:3:4;10297:20:11;:33;;;:59;;;;;;:::i;:::-;10264:20;:29;;;:93;;;;:::i;:::-;10246:111;-1:-1:-1;10379:21:11;10454:23;10467:10;10246:111;10454:23;:::i;:::-;10416:34;;;;10403:47;;;;:10;:47;:::i;:::-;:75;;;;:::i;:::-;10379:99;;10500:117;10517:22;10541:20;10582;:34;;;10563:53;;:16;:53;;;;:::i;:::-;10500:16;:117::i;:::-;10224:412;;9620:1030;10664:36;10679:20;10664:14;:36::i;:::-;-1:-1:-1;;10833:18:11;;;;;10816:36;;;;10722:10;10816:36;;;:16;:36;;;;;;;;:50;;;;10803:64;;:12;:64;;;;;10937:18;;10722:10;;10803:64;10722:10;;10922:58;;10803:64;10922:14;:58::i;:::-;10881:99;;11043:4;11011:7;:14;;;:29;;;11003:5;:37;;;;:::i;:::-;:44;;;;:::i;:::-;10995:52;;11078:8;11069:5;:17;;11061:45;;;;;;;6046:2:13;11061:45:11;;;6028:21:13;6085:2;6065:18;;;6058:30;6124:17;6104:18;;;6097:45;6159:18;;11061:45:11;5844:339:13;11061:45:11;11217:31;;11200:49;;;;11176:21;11200:49;;;:16;:49;;;;;;;;:63;11355:16;;;;11373:18;;11200:63;;;;;11278:170;;11294:22;;11217:20;;11200:63;;11355:16;11393:54;11217:20;11441:5;11393:25;:54::i;:::-;11278:15;:170::i;:::-;11463:36;11478:20;11463:14;:36::i;:::-;-1:-1:-1;;11615:18:11;;11600:34;;-1:-1:-1;11600:14:11;:34::i;:::-;11645:41;11664:7;11673:5;11680;11645:18;:41::i;:::-;9066:2627;;8962:2731;;;:::o;637:171:2:-;796:4;745:23;;;744:57;;;;774:26;;;744:57;;637:171;;;;;:::o;1483:601::-;1613:22;;;;1570:4;1613:22;;;:13;:22;;;;;:40;1570:4;;1613:40;;;;;;1692:41;;;;1748:22;1744:40;;1779:5;1772:12;;;;;;1744:40;1820:10;1798:32;;:18;:32;;;1794:49;;;1839:4;1832:11;;;;;;1794:49;1910:23;;;1854:53;1910:23;;;:14;:23;;;;;1958:1;1944:111;1965:17;1961:21;;:1;:21;1944:111;;;2021:10;2007:24;;:7;2015:1;2007:10;;;;;;;:::i;:::-;;;;;:24;2003:41;;;2040:4;2033:11;;;;;;;;2003:41;1984:3;;;:::i;:::-;;;1944:111;;;-1:-1:-1;2072:5:2;;1483:601;-1:-1:-1;;;;;;1483:601:2:o;23884:249::-;24021:61;;6753:42:13;6741:55;;24021:61:2;;;6723:74:13;23940:4:2;;;;23978:105;;2522:9:4;;24044:30:2;;6696:18:13;;24021:61:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23978:18;:105::i;:::-;23956:127;;24111:6;24100:26;;;;;;;;;;;;:::i;:::-;24093:33;23884:249;-1:-1:-1;;;23884:249:2:o;9023:686::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9164:52:2;9179:10;9191:12;9205:10;9164:14;:52::i;:::-;9160:543;;;9277:40;;;;9232:85;;;;;;;;;;;;;9358:21;;9454:25;;;;9424:55;;;;9332:47;;;;9424:55;9232:85;9332:23;;9424:55;9523:24;;;;9589:23;;;;9561:51;;;;9494:53;;;;9561:51;9494:26;;;9561:51;9662:30;;;;9627:32;;;:65;9023:686;;;;:::o;24139:467::-;24321:71;;6753:42:13;6741:55;;24321:71:2;;;6723:74:13;24203:20:2;;;;;;24278:115;;2522:9:4;;24344:38:2;;6696:18:13;;24321:71:2;6577:226:13;24278:115:2;24256:137;;24404:42;24461:6;24450:50;;;;;;;;;;;;:::i;:::-;24529:22;;24578:21;;;;;24529:22;;24578:21;;-1:-1:-1;24139:467:2;-1:-1:-1;;;;24139:467:2:o;6436:363:11:-;6534:4;6550:12;6625:22;6565:50;6604:10;6565:38;:50::i;:::-;:57;;6618:4;6565:57;:::i;:::-;:82;;;;:::i;:::-;6550:97;;6671:4;6661:7;:14;6657:34;;;-1:-1:-1;6687:4:11;6657:34;6756:4;6723:29;6756:4;813:8;6723:29;:::i;:::-;6712:41;;:7;:41;:::i;:::-;:48;;;;:::i;:::-;6702:58;-1:-1:-1;6778:14:11;6702:58;6788:4;6778:14;:::i;:::-;6771:21;6436:363;-1:-1:-1;;;;6436:363:11:o;4431:466:2:-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4560:28:2;;;;4532:25;4560:28;;;:16;:28;;;;;;;;;4532:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4598:69;;;;;;;8083:2:13;4598:69:2;;;8065:21:13;8122:2;8102:18;;;8095:30;8161:24;8141:18;;;8134:52;8203:18;;4598:69:2;7881:346:13;4598:69:2;4682:19;;;;4705:16;4682:39;;;;4678:88;;;1278:20:4;4723:19:2;;;:43;4678:88;4780:17;;;;4801:16;4780:37;;;;4776:90;;;1209:7:4;4819:17:2;;;:47;4884:6;4431:466;-1:-1:-1;;4431:466:2:o;17666:298::-;17897:27;;;17795:4;17897:27;;;:18;;;:27;;;;;:32;490:3:4;;17818:113:2;;17830:10;;17842:88;;17897:18;;17830:10;;17897:27;;:32;;;;;17842:19;:88::i;:::-;17818:11;:113::i;:::-;:139;;;;:::i;11611:220::-;11712:4;11728:17;11748:31;11768:10;11748:19;:31::i;:::-;11728:51;-1:-1:-1;11820:4:2;11796:21;11728:51;11796:6;:21;:::i;25110:701::-;25193:4;25209:17;1064:12:4;25229:6:2;:34;;:70;;25293:6;25229:70;;;1064:12:4;25229:70:2;25209:90;-1:-1:-1;25309:17:2;25329:39;25209:90;1064:12:4;25329:39:2;:::i;:::-;25309:59;;25379:25;25430:20;25452:19;25475:28;25495:7;25475:19;:28::i;:::-;25429:74;;;;25558:14;25540:15;:32;:71;;25610:1;25540:71;;;25575:32;25593:14;25575:15;:32;:::i;:::-;25517:94;;25415:207;;1064:12:4;25764::2;25741:20;:35;;;;:::i;:::-;:62;;;;:::i;:::-;25640:22;;;;;;;:13;:22;;;;;:39;;;1064:12:4;;25640:54:2;;25682:12;;25640:54;:::i;:::-;:81;;;;:::i;:::-;25639:165;;;;:::i;:::-;25632:172;25110:701;-1:-1:-1;;;;;;25110:701:2:o;21025:1228::-;21199:11;21213:36;490:3:4;21213:10:2;:36;:::i;:::-;21199:50;;21261:13;21276:17;21297:48;21314:12;21328:10;21340:4;21297:16;:48::i;:::-;21260:85;;;;21356:11;21369:15;21388:46;21405:12;21419:10;21431:2;21388:16;:46::i;:::-;21355:79;;;;21449:6;21459:1;21449:11;21445:57;;;21462:40;21476:2;21480:10;:21;;;21462:13;:40::i;:::-;21590:8;21581:6;:17;:64;;;;-1:-1:-1;490:3:4;21602:17:2;21611:8;21602:6;:17;:::i;:::-;:43;21581:64;21577:87;;;21656:8;21647:17;;21577:87;21695:6;21683:8;:18;;21675:53;;;;;;;8434:2:13;21675:53:2;;;8416:21:13;8473:2;8453:18;;;8446:30;8512:24;8492:18;;;8485:52;8554:18;;21675:53:2;8232:346:13;21675:53:2;21762:6;21750:18;;;;490:3:4;21823:8:2;:34;21819:109;;;21873:18;21883:8;21873:18;;:::i;:::-;;;21916:1;21905:12;;21819:109;21938:16;21948:6;21938:16;;:::i;:::-;;;21997:26;22014:8;21997:16;:26::i;:::-;21965:24;;;;;;;:18;;;:24;;;;;:58;;;;;;;;;;;;;;;;;;;22063:24;22080:6;22063:16;:24::i;:::-;22033:22;;;;;;;:18;;;:22;;;;;:54;;;;;;;;;;;;;;;;;;;22098:72;22114:10;22126:13;22141:4;22147:12;22161:8;22098:15;:72::i;:::-;22180:66;22196:10;22208:13;22223:2;22227:10;22239:6;22180:15;:66::i;:::-;21189:1064;;;;;21025:1228;;;;;;:::o;19213:850::-;19374:33;490:3:4;19374:33:2;;:::i;:::-;19426:22;;;;19374:33;;-1:-1:-1;19426:48:2;;1806:1:4;19426:48:2;;;:101;;-1:-1:-1;19491:21:2;;19478:49;:35;;;19525:1;19478:35;;;:12;:35;;;;;;;:49;19426:101;19418:136;;;;;;;8785:2:13;19418:136:2;;;8767:21:13;8824:2;8804:18;;;8797:30;8863:24;8843:18;;;8836:52;8905:18;;19418:136:2;8583:346:13;19418:136:2;19566:9;19577:13;19594:51;19611:12;19625:10;19637:7;19594:16;:51::i;:::-;19565:80;;;;19660:4;19668:1;19660:9;19656:60;;;19671:45;19685:7;19694:10;:21;;;19671:13;:45::i;:::-;19727:14;19735:6;19727:14;;:::i;:::-;;;19787:22;19804:4;19787:16;:22::i;:::-;19752:27;;;;;;;:18;;;:27;;;;;;;:57;;;;;;;;;;;;;19890:23;;;19873:50;;19890:32;;19916:6;;19890:32;;:::i;:::-;19873:16;:50::i;:::-;19847:76;;:23;;;:76;;;19819:25;;;:104;;;;;;;;;;;;;;19934:44;19819:25;19847:23;19934:18;:44::i;:::-;19989:67;20005:10;20017:13;20032:7;20041:8;20051:4;19989:15;:67::i;:::-;19364:699;;19213:850;;;;;:::o;22278:354::-;22459:53;22505:6;22477:10;:25;;;:34;;;;;;:::i;:::-;22459:17;:53::i;:::-;22431:81;;:25;;;:81;;;22401:27;;;:111;;;;;;;;;;;;;;22591:24;;;;22578:47;;22591:33;;22618:6;;22591:33;;;:::i;:::-;22578:12;:47::i;:::-;22551:74;;:24;;;;:74;;;-1:-1:-1;22522:26:2;;;;:103;;;;;;;;;22278:354::o;13591:246::-;13672:1;:12;;;13660:170;;;13686:1;:15;;;490:3:4;13703:1:2;:14;;;:40;;;;;;:::i;:::-;13745:16;;;;;13763:10;;;;13775:21;;;;;13798:14;;;;13660:170;;;9273:30:13;9261:43;;;9243:62;;9336:2;9321:18;;9314:34;;;;9396:26;9384:39;;;9364:18;;;9357:67;;;;9440:18;;;9433:34;9483:19;;;9476:35;;;;9559:2;9548:22;9542:3;9527:19;;9520:51;13814:15:2;9602:3:13;9587:19;;9580:35;9230:3;9215:19;13660:170:2;;;;;;;13591:246;:::o;11129:220::-;11230:4;11246:17;11266:31;11286:10;11266:19;:31::i;:::-;11246:51;-1:-1:-1;11246:51:2;11314:13;:6;11323:4;11314:13;:::i;15131:749::-;15325:24;;;15302:20;15325:24;;;:18;;;:24;;;;;:32;;;15375:25;;;;15367:60;;;;;;;8434:2:13;15367:60:2;;;8416:21:13;8473:2;8453:18;;;8446:30;8512:24;8492:18;;;8485:52;8554:18;;15367:60:2;8232:346:13;15367:60:2;15495:24;;;15567:28;15495:24;15567:12;:28::i;:::-;15532:24;;;;;;;;:18;;;:24;;;;;;:63;;;;;;;;;;;15651:22;;;;;;:30;15638:53;;15651:39;;15684:6;;15651:30;:39;:::i;15638:53::-;15605:22;;;;;;;;:18;;;:22;;;;;;;;;:86;;;;;;;;;;;;;;;;15716:21;;15707:45;;1360:25:13;;;15707:45:2;;;;;;;;;;;1333:18:13;15707:45:2;;;;;;;15775:21;;15767:42;;1360:25:13;;;15767:42:2;;;;;;;;;1348:2:13;1333:18;15767:42:2;;;;;;;15819:54;15841:13;15856:4;15862:2;15866:6;15819:21;:54::i;:::-;15292:588;;15131:749;;;;;;:::o;24612:446::-;24687:22;;;24672:12;24687:22;;;:13;:22;;;;;:43;;;24745:30;24741:311;;24834:71;;6753:42:13;6741:55;;24834:71:2;;;6723:74:13;24791:115:2;;2522:9:4;;24857:38:2;;6696:18:13;;24834:71:2;6577:226:13;24791:115:2;;24662:396;24612:446;:::o;24741:311::-;24927:31;;;1555:1:4;24927:31:2;24923:129;;;24974:22;;;;;;;:13;:22;;;;;:67;;;;1610:1:4;24974:67:2;;;24923:129;24662:396;24612:446;:::o;11699:301:11:-;11858:18;;;;;11840:16;;;;;11820:18;;11878;;;;;11912:14;;;;;:26;;;;11940:27;;;;11969:23;;;;;11808:185;;;9931:55:13;;;9913:74;;10003:18;;;9996:34;;;10046:18;;;10039:34;;;10089:18;;;10082:34;10132:19;;10125:35;;;;10191:3;10176:19;;10169:35;;;;11808:185:11;;;;;;;;;;;;;9885:19:13;11808:185:11;;;;;;;11699:301;;;:::o;1063:258:0:-;1169:12;1206:22;;;:12;:22;;;;;;;:42;;1144:12;;1169;;;1206:22;;;;;:42;;1242:5;;1206:42;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1168:80;;;;1263:7;1258:33;;1272:19;1284:6;1272:11;:19::i;5504:3513:2:-;5682:34;;;;;5796:42;;;;;5753:40;;;:85;5907:31;;;;;;;5875:29;;;:63;;;5979:30;;;;;;;5948:28;;;:61;6045:25;;;;;5796:42;6019:23;;:51;6104:23;;;;;6080:21;;;:47;6162:24;;;;;6137:22;;;:49;6227:30;;;;;;;6196:28;;;:61;5796:42;6296:27;;;;;;;;6268:25;;;:55;6361:26;;;;;;;;6334:24;;;:53;6423:25;;;;;;-1:-1:-1;6397:23:2;;:51;6492:32;;;;-1:-1:-1;6459:30:2;;:65;6628:2;:23;;;6623:29;;;6045:25;6623:29;6585:35;;;:67;;;-1:-1:-1;;5907:31:2;6623:29;6697:53;;;;:::i;:::-;;6666:28;;;:84;6771:13;6787:40;6666:10;6821:4;6787:13;:40::i;:::-;6771:56;;6853:10;:28;;;6841:8;:40;6837:207;;6942:35;;;;6931:46;;6909:19;;;:68;6837:207;;;7032:1;7010:19;;;:23;6837:207;7130:10;:40;;;7111:59;;:15;:59;7107:1904;;7194:4;7186:12;;7213:11;7245:10;:40;;;7227:58;;:15;:58;;;;:::i;:::-;7213:72;;7335:27;7469:4;7435:10;:30;;;7366:66;7385:10;:23;;;7381:28;;7412:4;7381:35;;;;:::i;:::-;7419:6;7427:4;7366:9;:66::i;:::-;:99;;;;:::i;:::-;7365:108;;;;:::i;:::-;7335:138;;7488:20;7562:10;:30;;;7537:22;7511:10;:23;;;:48;;;;;;:::i;:::-;:81;;;;:::i;:::-;7632:25;;;;7695:24;;;;7488:104;;-1:-1:-1;7607:50:2;;;7671:48;;7607:22;7952:43;490:3:4;824:13;7952:43:2;:::i;:::-;7829:21;;;;7854:16;7829:41;;;;:87;;7895:10;:21;;;7829:87;;;923:20:4;7829:87:2;7751:166;;7770:10;:23;;;7752:41;;:15;:41;;;;:::i;:::-;7751:166;;;;:::i;:::-;:245;;;;:::i;:::-;7734:262;-1:-1:-1;8015:14:2;;8011:311;;8049:15;8090:41;490:3:4;8090:15:2;:41;:::i;:::-;8067:10;:19;;;:65;;;;:::i;:::-;8049:83;-1:-1:-1;8202:22:2;8215:9;8049:83;8202:22;:::i;:::-;8169:29;8182:16;8169:10;:29;:::i;:::-;:56;;;;:::i;:::-;8150:75;;8283:10;:24;;;8264:43;;:16;:43;;;;:::i;:::-;8243:64;;;;:::i;:::-;;;8031:291;8011:311;280:17:4;8420:35:2;;;;;:78;;-1:-1:-1;418:17:4;8459:39:2;;;8420:78;8416:585;;;8544:33;8561:15;8544:16;:33::i;:::-;8518:59;;:23;;;:59;8595:30;;;:55;;;8668:66;8718:15;8668:66;:40;;;:66;8777:24;;;;8757:44;;;;8753:234;;8853:36;8871:17;8853;:36::i;:::-;8825:64;;:25;;;:64;8938:30;8951:16;8938:12;:30::i;:::-;8911:57;;:24;;;:57;8753:234;7172:1839;;;;;;7107:1904;5648:3369;;5504:3513;;;;;:::o;26258:376::-;26376:22;;;;26341:4;26376:22;;;:13;:22;;;;;:47;;;26341:4;;26376:47;26441:22;;;;;:85;;-1:-1:-1;26467:59:2;:23;;;;;;;:13;:23;;;;;:48;;;;;:59;;;;26441:85;:186;;26592:35;26619:7;26592:26;:35::i;:::-;26441:186;;;26541:36;26568:8;26541:26;:36::i;16531:461::-;16676:4;16751:9;16747:23;;-1:-1:-1;16769:1:2;16762:8;;16747:23;16938:27;;;;;;;:18;;;:27;;;;;:47;;;16905:30;;;;16898:37;;:4;:37;:::i;:::-;:87;;;;:::i;:::-;16891:94;16531:461;-1:-1:-1;;;;;16531:461:2:o;17290:304::-;17374:4;17394:9;17390:23;;-1:-1:-1;17412:1:2;17405:8;;17390:23;17487:35;;;;490:3:4;17461:61:2;;;17544:16;:12;;;:16;17461:61;17543:26;;;;:::i;:::-;;:34;;17290:304;-1:-1:-1;;;;17290:304:2:o;10847:276::-;10928:4;10948:10;:24;;;:29;;10976:1;10948:29;10944:46;;;-1:-1:-1;10986:4:2;;10847:276;-1:-1:-1;10847:276:2:o;10944:46::-;11092:10;:24;;;11007:109;;490:3:4;11031:10:2;:23;;;:49;;;;;;:::i;:::-;11008:10;:19;;;:73;;;;:::i;:::-;11007:82;;11085:4;11007:82;:::i;:::-;:109;;;;:::i;17970:490::-;18160:27;;;18095:17;18160:27;;;:18;;;:27;;;;;:32;;;;;;18218:69;18160:18;18252:10;18160:27;:32;18218:19;:69::i;:::-;18203:84;;18333:30;18350:12;18333:16;:30::i;:::-;18298:27;;;;;;;;:18;;;;:27;;;;;;:65;;;;;;;;;;;;;;;;;;;18423:30;;;;;-1:-1:-1;18373:47:2;;;:80;17970:490;:::o;2090:937::-;2209:22;;;2169:37;2209:22;;;:13;:22;;;;;;;;2269:32;;2367:14;:23;;;;;2269:32;;;;;;;2405:22;;2401:277;;2447:33;;:47;;;;:33;;;;;:47;2443:60;;;2496:7;;;2090:937;;:::o;2443:60::-;2549:1;2535:133;2556:17;2552:21;;:1;:21;2535:133;;;2616:10;2602:24;;:7;2610:1;2602:10;;;;;;;:::i;:::-;;;;;:24;2598:37;;;2628:7;;;;2090:937;;:::o;2598:37::-;2575:3;;;;:::i;:::-;;;;2535:133;;;;2401:277;544:2:4;2696:17:2;:39;;;2688:78;;;;;;;11220:2:13;2688:78:2;;;11202:21:13;11259:2;11239:18;;;11232:30;11298:28;11278:18;;;11271:56;11344:18;;2688:78:2;11018:350:13;2688:78:2;2781:22;;;2777:128;;2805:46;;;;;;;;;;;;2777:128;;;2895:10;2866:7;2874:17;2866:26;;;;;;;;;:::i;:::-;;:39;;;;;;;;;;;;;;;2777:128;2951:21;:17;2971:1;2951:21;:::i;:::-;2916:56;;;;;;;;;;;;;;;;2988:32;;;;;;;;;;;;;2916;;2988;2159:868;;;2090:937;;:::o;10645:196::-;10707:7;418:17:4;10734:30:2;;;10726:76;;;;;;;11808:2:13;10726:76:2;;;11790:21:13;11847:2;11827:18;;;11820:30;11886:34;11866:18;;;11859:62;11957:3;11937:18;;;11930:31;11978:19;;10726:76:2;11606:397:13;10726:76:2;-1:-1:-1;10827:6:2;10645:196::o;18466:741::-;490:3:4;18616:33:2;18628:10;18640:8;18616:11;:33::i;:::-;:59;;;;:::i;:::-;18605:70;;490:3:4;18692:29:2;18704:10;18716:4;18692:11;:29::i;:::-;:55;;;;:::i;:::-;18685:62;;18769:8;18762:4;:15;18758:443;;;18793:11;18807:15;18814:8;18807:4;:15;:::i;:::-;18793:29;;18871:7;18841:46;;18848:10;:21;;;18841:46;;;18880:6;18841:46;;;;1360:25:13;;1348:2;1333:18;;1214:177;18841:46:2;;;;;;;;18901:65;18923:13;18946:1;18950:7;18959:6;18901:21;:65::i;:::-;18779:198;18758:443;;;18998:4;18987:8;:15;18983:218;;;19018:11;19032:15;19043:4;19032:8;:15;:::i;:::-;19018:29;;19095:7;19066:45;;19072:10;:21;;;19066:45;;;19104:6;19066:45;;;;1360:25:13;;1348:2;1333:18;;1214:177;19066:45:2;;;;;;;;19125:65;19147:13;19162:7;19179:1;19183:6;19125:21;:65::i;:::-;19004:197;18466:741;;;;;:::o;12700:885::-;12812:18;12855:17;490:3:4;12875:10:2;:23;;;:49;;;;;;:::i;:::-;12855:69;;12938:15;12978:12;12956:10;:19;;;:34;;;;:::i;:::-;12938:52;-1:-1:-1;13008:15:2;13004:192;;13039:1;13025:15;;13004:192;;;13191:4;13178:10;13145:29;13150:16;13191:4;13145:29;:::i;:::-;13129:46;;:12;:46;:::i;:::-;:59;;;;:::i;:::-;:66;;;;:::i;:::-;13108:88;;13004:192;-1:-1:-1;;13258:28:2;;;;13398:21;;13337:96;;12210:42:13;12198:55;;;13337:96:2;;;12180:74:13;13239:195:2;12290:23:13;;;12270:18;;;12263:51;13217:19:2;;13239:195;;;;;13360:36;;12153:18:13;;13337:96:2;12008:312:13;13239:195:2;13217:217;;13446:21;13482:6;13471:27;;;;;;;;;;;;:::i;:::-;13537:41;;;;:23;;;;:41;;;;-1:-1:-1;;13509:69:2;;;;;;;;;;;;;;;;;;;-1:-1:-1;12700:885:2:o;10442:197::-;10505:6;350:16:4;10531:31:2;;;10523:78;;;;;;;12810:2:13;10523:78:2;;;12792:21:13;12849:2;12829:18;;;12822:30;12888:34;12868:18;;;12861:62;12959:4;12939:18;;;12932:32;12981:19;;10523:78:2;12608:398:13;10254:182:2;10312:7;280:17:4;10339:25:2;;;10331:66;;;;;;;13213:2:13;10331:66:2;;;13195:21:13;13252:2;13232:18;;;13225:30;13291;13271:18;;;13264:58;13339:18;;10331:66:2;13011:352:13;1078:531:3;2048:19:0;2125:4;2119:11;2101:29;;1194:12:3::1;1211:9;:14;;1281:1;1326:42;;;;;;;;;;;;;;;;;1316:53:::0;;::::1;::::0;;::::1;::::0;1226:329:::1;::::0;13625:3:13;13621:16;;;;13639:66;13617:89;1226:329:3;;::::1;13605:102:13::0;;;;13723:11;;;13716:27;1410:19:3::1;::::0;;::::1;13759:12:13::0;;;13752:28;1471:17:3;::::1;13796:12:13::0;;;13789:28;13833:12;;;13826:28;;;13870:13;;1226:329:3::1;::::0;;;;;::::1;::::0;;;;;;;1211:345:::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1193:363;;;1574:7;1566:36;;;::::0;::::1;::::0;;14096:2:13;1566:36:3::1;::::0;::::1;14078:21:13::0;14135:2;14115:18;;;14108:30;14174:18;14154;;;14147:46;14210:18;;1566:36:3::1;13894:340:13::0;1566:36:3::1;-1:-1:-1::0;2512:4:0;2505:28;-1:-1:-1;;;;1078:531:3:o;2580:232:0:-;2650:13;;:17;2646:126;;2740:6;2734:13;2725:6;2721:2;2717:15;2710:38;2646:126;2782:23;;;;;14441:2:13;2782:23:0;;;14423:21:13;14480:2;14460:18;;;14453:30;14519:15;14499:18;;;14492:43;14552:18;;2782:23:0;14239:337:13;11837:857:2;2125:4:0;2119:11;;12105:21:2;;:32:::1;6741:55:13::0;;;12150:58:2::1;::::0;;::::1;6723:74:13::0;;;;12150:58:2;;;;;;;;;;6696:18:13;;;12150:58:2;;::::1;::::0;::::1;::::0;;::::1;;12173:25:::0;12150:58:::1;::::0;;12105:104;;11938:4;;;;;;12105:32:::1;::::0;12143:5:::1;::::0;12105:104:::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12069:140;;;;12605:7;12604:8;:28;;;;12630:2;12616:4;:11;:16;12604:28;12600:42;;;12641:1;12634:8;;;;;;12600:42;12671:4;12660:27;;;;;;;;;;;;:::i;:::-;12653:34;;;;2150:1:0;2512:4:::0;2505:28;11837:857:2;;-1:-1:-1;;11837:857:2:o;835:1036:12:-;899:6;947:1;949:53;;;;1048:9;;;1058:20;;;;1094:1;1089:6;;1041:56;;1058:20;1072:4;1067:9;;1041:56;;1136:1;1130:4;1126:12;1191:1;1188;1184:9;1179:14;;1173:668;1196:1;1173:668;;;1255:1;1252;1248:9;1303:1;1299;1295:2;1291:10;1288:17;1278:44;;1318:1;1316;1309:11;1278:44;1366:4;1362:2;1358:13;1407:2;1398:7;1395:15;1392:34;;;1422:1;1420;1413:11;1392:34;1452:18;;;;-1:-1:-1;;1494:8:12;;;1491:332;;;1546:1;1543;1539:9;1621:1;1617;1613:2;1609:10;1606:17;1599:25;1594:1;1587:9;1580:17;1576:49;1573:68;;;1637:1;1635;1628:11;1573:68;1689:4;1685:2;1681:13;1734:2;1725:7;1722:15;1719:34;;;1749:1;1747;1740:11;1719:34;1783:18;;;;-1:-1:-1;;1491:332:12;1211:1;1209;1205:8;1200:13;;1173:668;;;1177:18;940:915;;949:53;964:1;966:18;;;;999:1;994:6;;957:44;;966:18;979:4;974:9;;957:44;940:915;;835:1036;;;;;:::o;25817:435:2:-;25938:22;;;25888:4;25938:22;;;:13;:22;;;;;:49;;;;;;;25997:45;;-1:-1:-1;26041:1:2;;25817:435;-1:-1:-1;;25817:435:2:o;25997:45::-;26053:11;26067:44;26085:26;26067:15;:44;:::i;:::-;26053:58;-1:-1:-1;26125:11:2;26121:63;;-1:-1:-1;;;26145:22:2;;;;;;:13;:22;;;;;:39;;;;25817:435::o;26121:63::-;26202:43;26229:7;26238:6;26202:26;:43::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:196:13:-;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:409::-;301:6;309;317;325;378:3;366:9;357:7;353:23;349:33;346:53;;;395:1;392;385:12;346:53;418:29;437:9;418:29;:::i;:::-;408:39;;466:38;500:2;489:9;485:18;466:38;:::i;:::-;456:48;;523:38;557:2;546:9;542:18;523:38;:::i;:::-;513:48;;580:38;614:2;603:9;599:18;580:38;:::i;:::-;570:48;;215:409;;;;;;;:::o;1578:472::-;1673:6;1681;1689;1697;1705;1758:3;1746:9;1737:7;1733:23;1729:33;1726:53;;;1775:1;1772;1765:12;1726:53;1798:29;1817:9;1798:29;:::i;:::-;1788:39;;1846:38;1880:2;1869:9;1865:18;1846:38;:::i;:::-;1836:48;;1903:38;1937:2;1926:9;1922:18;1903:38;:::i;:::-;1578:472;;;;-1:-1:-1;1893:48:13;;1988:2;1973:18;;1960:32;;-1:-1:-1;2039:3:13;2024:19;2011:33;;1578:472;-1:-1:-1;;1578:472:13:o;4334:184::-;4386:77;4383:1;4376:88;4483:4;4480:1;4473:15;4507:4;4504:1;4497:15;4523:228;4563:7;4689:1;4621:66;4617:74;4614:1;4611:81;4606:1;4599:9;4592:17;4588:105;4585:131;;;4696:18;;:::i;:::-;-1:-1:-1;4736:9:13;;4523:228::o;4756:184::-;4808:77;4805:1;4798:88;4905:4;4902:1;4895:15;4929:4;4926:1;4919:15;4945:274;4985:1;5011;5001:189;;5046:77;5043:1;5036:88;5147:4;5144:1;5137:15;5175:4;5172:1;5165:15;5001:189;-1:-1:-1;5204:9:13;;4945:274::o;5224:125::-;5264:4;5292:1;5289;5286:8;5283:34;;;5297:18;;:::i;:::-;-1:-1:-1;5334:9:13;;5224:125::o;5354:128::-;5394:3;5425:1;5421:6;5418:1;5415:13;5412:39;;;5431:18;;:::i;:::-;-1:-1:-1;5467:9:13;;5354:128::o;6188:184::-;6240:77;6237:1;6230:88;6337:4;6334:1;6327:15;6361:4;6358:1;6351:15;6377:195;6416:3;6447:66;6440:5;6437:77;6434:103;;;6517:18;;:::i;:::-;-1:-1:-1;6564:1:13;6553:13;;6377:195::o;6808:184::-;6878:6;6931:2;6919:9;6910:7;6906:23;6902:32;6899:52;;;6947:1;6944;6937:12;6899:52;-1:-1:-1;6970:16:13;;6808:184;-1:-1:-1;6808:184:13:o;6997:879::-;7100:6;7153:3;7141:9;7132:7;7128:23;7124:33;7121:53;;;7170:1;7167;7160:12;7121:53;7203:2;7197:9;7245:3;7237:6;7233:16;7315:6;7303:10;7300:22;7279:18;7267:10;7264:34;7261:62;7258:242;;;7356:77;7353:1;7346:88;7457:4;7454:1;7447:15;7485:4;7482:1;7475:15;7258:242;7520:10;7516:2;7509:22;;7561:9;7555:16;7547:6;7540:32;7626:2;7615:9;7611:18;7605:25;7600:2;7592:6;7588:15;7581:50;7685:2;7674:9;7670:18;7664:25;7659:2;7651:6;7647:15;7640:50;7733:2;7722:9;7718:18;7712:25;7780:5;7773:13;7766:21;7759:5;7756:32;7746:60;;7802:1;7799;7792:12;7746:60;7834:2;7822:15;;7815:30;7826:6;6997:879;-1:-1:-1;;;6997:879:13:o;10215:426::-;10344:3;10382:6;10376:13;10407:1;10417:129;10431:6;10428:1;10425:13;10417:129;;;10529:4;10513:14;;;10509:25;;10503:32;10490:11;;;10483:53;10446:12;10417:129;;;10564:6;10561:1;10558:13;10555:48;;;10599:1;10590:6;10585:3;10581:16;10574:27;10555:48;-1:-1:-1;10619:16:13;;;;;10215:426;-1:-1:-1;;10215:426:13:o;10646:367::-;10685:3;10720:1;10717;10713:9;10829:1;10761:66;10757:74;10754:1;10750:82;10745:2;10738:10;10734:99;10731:125;;;10836:18;;:::i;:::-;10955:1;10887:66;10883:74;10880:1;10876:82;10872:2;10868:91;10865:117;;;10962:18;;:::i;:::-;-1:-1:-1;;10998:9:13;;10646:367::o;11373:228::-;11412:3;11440:10;11477:2;11474:1;11470:10;11507:2;11504:1;11500:10;11538:3;11534:2;11530:12;11525:3;11522:21;11519:47;;;11546:18;;:::i;:::-;11582:13;;11373:228;-1:-1:-1;;;;11373:228:13:o;12325:278::-;12393:6;12446:2;12434:9;12425:7;12421:23;12417:32;12414:52;;;12462:1;12459;12452:12;12414:52;12494:9;12488:16;12548:5;12544:2;12533:21;12526:5;12523:32;12513:60;;12569:1;12566;12559:12

Swarm Source

ipfs://a59a83d001e3425fb3c04d1a177ce07d8f79bab79b81c62d1cddcd2c213bdf30
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.

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.