Overview
ETH Balance
0 ETHETH Value
$0.00Token Holdings
- ERC-20 Tokens (1)View All Holdings1 BLB
ERC-20: Bala... (BLB)
More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 4,435 transactions
| Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
| Approve | 17687615 | 19 days ago | IN | 0 ETH | 0.00002895 | ||||
| Approve | 17685994 | 19 days ago | IN | 0 ETH | 0.00002909 | ||||
| Approve | 17683654 | 19 days ago | IN | 0 ETH | 0.00002898 | ||||
| Approve | 17681135 | 19 days ago | IN | 0 ETH | 0.00002896 | ||||
| Approve | 17680896 | 19 days ago | IN | 0 ETH | 0.00002898 | ||||
| Approve | 17678780 | 19 days ago | IN | 0 ETH | 0.00002906 | ||||
| Approve | 17676228 | 19 days ago | IN | 0 ETH | 0.00002899 | ||||
| Approve | 17674434 | 19 days ago | IN | 0 ETH | 0.0000289 | ||||
| Approve | 14597670 | 98 days ago | IN | 0 ETH | 0.00002901 | ||||
| Approve | 14593911 | 98 days ago | IN | 0 ETH | 0.00002909 | ||||
| Approve | 14592438 | 98 days ago | IN | 0 ETH | 0.00002896 | ||||
| Approve | 14585112 | 98 days ago | IN | 0 ETH | 0.00002899 | ||||
| Approve | 14584169 | 98 days ago | IN | 0 ETH | 0.00002896 | ||||
| Approve | 14583126 | 98 days ago | IN | 0 ETH | 0.00002907 | ||||
| Approve | 14578614 | 98 days ago | IN | 0 ETH | 0.00002897 | ||||
| Approve | 13416140 | 127 days ago | IN | 0 ETH | 0.00002896 | ||||
| Approve | 13410698 | 127 days ago | IN | 0 ETH | 0.00002899 | ||||
| Approve | 13410241 | 127 days ago | IN | 0 ETH | 0.00002908 | ||||
| Approve | 13409174 | 127 days ago | IN | 0 ETH | 0.00002893 | ||||
| Approve | 12620673 | 146 days ago | IN | 0 ETH | 0.00002907 | ||||
| Approve | 12618098 | 146 days ago | IN | 0 ETH | 0.00002895 | ||||
| Approve | 12614592 | 146 days ago | IN | 0 ETH | 0.00002901 | ||||
| Approve | 12611982 | 146 days ago | IN | 0 ETH | 0.00002887 | ||||
| Approve | 12608178 | 146 days ago | IN | 0 ETH | 0.00002901 | ||||
| Approve | 10455833 | 197 days ago | IN | 0 ETH | 0.00002885 |
Latest 25 internal transactions (View All)
| Parent Transaction Hash | Block | From | To | |||
|---|---|---|---|---|---|---|
| 5607066 | 310 days ago | 0 ETH | ||||
| 5607066 | 310 days ago | 0 ETH | ||||
| 5607052 | 310 days ago | 0 ETH | ||||
| 5607052 | 310 days ago | 0 ETH | ||||
| 5607035 | 310 days ago | 0.00008575 ETH | ||||
| 5607035 | 310 days ago | 0 ETH | ||||
| 5607035 | 310 days ago | 0 ETH | ||||
| 5607035 | 310 days ago | 0 ETH | ||||
| 5607035 | 310 days ago | 0 ETH | ||||
| 5607035 | 310 days ago | 0 ETH | ||||
| 5607035 | 310 days ago | 0 ETH | ||||
| 5607035 | 310 days ago | 0 ETH | ||||
| 5607035 | 310 days ago | 0 ETH | ||||
| 5118312 | 324 days ago | 0 ETH | ||||
| 5118312 | 324 days ago | 0 ETH | ||||
| 2799867 | 409 days ago | 0 ETH | ||||
| 2799867 | 409 days ago | 0 ETH | ||||
| 2799867 | 409 days ago | 0 ETH | ||||
| 2799867 | 409 days ago | 0 ETH | ||||
| 2799867 | 409 days ago | 0 ETH | ||||
| 2262671 | 433 days ago | 0.01 ETH | ||||
| 2262671 | 433 days ago | 0 ETH | ||||
| 2262671 | 433 days ago | 0 ETH | ||||
| 2262671 | 433 days ago | 0 ETH | ||||
| 2262671 | 433 days ago | 0 ETH |
Loading...
Loading
Contract Name:
CEther
Compiler Version
v0.8.10+commit.fc410830
Contract Source Code (Solidity)
/**
*Submitted for verification at lineascan.build/ on 2023-07-19
*/
// File: contracts\ComptrollerInterface.sol
pragma solidity ^0.8.10;
abstract contract ComptrollerInterface {
/// @notice Indicator that this is a Comptroller contract (for inspection)
bool public constant isComptroller = true;
/*** Assets You Are In ***/
function enterMarkets(address[] calldata cTokens) virtual external returns (uint[] memory);
function exitMarket(address cToken) virtual external returns (uint);
/*** Policy Hooks ***/
function mintAllowed(address cToken, address minter, uint mintAmount) virtual external returns (uint);
function mintVerify(address cToken, address minter, uint mintAmount, uint mintTokens) virtual external;
function redeemAllowed(address cToken, address redeemer, uint redeemTokens) virtual external returns (uint);
function redeemVerify(address cToken, address redeemer, uint redeemAmount, uint redeemTokens) virtual external;
function borrowAllowed(address cToken, address borrower, uint borrowAmount) virtual external returns (uint);
function borrowVerify(address cToken, address borrower, uint borrowAmount) virtual external;
function repayBorrowAllowed(
address cToken,
address payer,
address borrower,
uint repayAmount) virtual external returns (uint);
function repayBorrowVerify(
address cToken,
address payer,
address borrower,
uint repayAmount,
uint borrowerIndex) virtual external;
function liquidateBorrowAllowed(
address cTokenBorrowed,
address cTokenCollateral,
address liquidator,
address borrower,
uint repayAmount) virtual external returns (uint);
function liquidateBorrowVerify(
address cTokenBorrowed,
address cTokenCollateral,
address liquidator,
address borrower,
uint repayAmount,
uint seizeTokens) virtual external;
function seizeAllowed(
address cTokenCollateral,
address cTokenBorrowed,
address liquidator,
address borrower,
uint seizeTokens) virtual external returns (uint);
function seizeVerify(
address cTokenCollateral,
address cTokenBorrowed,
address liquidator,
address borrower,
uint seizeTokens) virtual external;
function transferAllowed(address cToken, address src, address dst, uint transferTokens) virtual external returns (uint);
function transferVerify(address cToken, address src, address dst, uint transferTokens) virtual external;
/*** Liquidity/Liquidation Calculations ***/
function liquidateCalculateSeizeTokens(
address cTokenBorrowed,
address cTokenCollateral,
uint repayAmount) virtual external view returns (uint, uint);
}
// File: contracts\InterestRateModel.sol
pragma solidity ^0.8.10;
/**
* @title Compound's InterestRateModel Interface
* @author Compound
*/
abstract contract InterestRateModel {
/// @notice Indicator that this is an InterestRateModel contract (for inspection)
bool public constant isInterestRateModel = true;
/**
* @notice Calculates the current borrow interest rate per block
* @param cash The total amount of cash the market has
* @param borrows The total amount of borrows the market has outstanding
* @param reserves The total amount of reserves the market has
* @return The borrow rate per block (as a percentage, and scaled by 1e18)
*/
function getBorrowRate(uint cash, uint borrows, uint reserves) virtual external view returns (uint);
/**
* @notice Calculates the current supply interest rate per block
* @param cash The total amount of cash the market has
* @param borrows The total amount of borrows the market has outstanding
* @param reserves The total amount of reserves the market has
* @param reserveFactorMantissa The current reserve factor the market has
* @return The supply rate per block (as a percentage, and scaled by 1e18)
*/
function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) virtual external view returns (uint);
}
// File: contracts\EIP20NonStandardInterface.sol
pragma solidity ^0.8.10;
/**
* @title EIP20NonStandardInterface
* @dev Version of ERC20 with no return values for `transfer` and `transferFrom`
* See https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
*/
interface EIP20NonStandardInterface {
/**
* @notice Get the total number of tokens in circulation
* @return The supply of tokens
*/
function totalSupply() external view returns (uint256);
/**
* @notice Gets the balance of the specified address
* @param owner The address from which the balance will be retrieved
* @return balance The balance
*/
function balanceOf(address owner) external view returns (uint256 balance);
///
/// !!!!!!!!!!!!!!
/// !!! NOTICE !!! `transfer` does not return a value, in violation of the ERC-20 specification
/// !!!!!!!!!!!!!!
///
/**
* @notice Transfer `amount` tokens from `msg.sender` to `dst`
* @param dst The address of the destination account
* @param amount The number of tokens to transfer
*/
function transfer(address dst, uint256 amount) external;
///
/// !!!!!!!!!!!!!!
/// !!! NOTICE !!! `transferFrom` does not return a value, in violation of the ERC-20 specification
/// !!!!!!!!!!!!!!
///
/**
* @notice Transfer `amount` tokens from `src` to `dst`
* @param src The address of the source account
* @param dst The address of the destination account
* @param amount The number of tokens to transfer
*/
function transferFrom(address src, address dst, uint256 amount) external;
/**
* @notice Approve `spender` to transfer up to `amount` from `src`
* @dev This will overwrite the approval amount for `spender`
* and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
* @param spender The address of the account which may transfer tokens
* @param amount The number of tokens that are approved
* @return success Whether or not the approval succeeded
*/
function approve(address spender, uint256 amount) external returns (bool success);
/**
* @notice Get the current allowance from `owner` for `spender`
* @param owner The address of the account which owns the tokens to be spent
* @param spender The address of the account which may transfer tokens
* @return remaining The number of tokens allowed to be spent
*/
function allowance(address owner, address spender) external view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
}
// File: contracts\ErrorReporter.sol
pragma solidity ^0.8.10;
contract ComptrollerErrorReporter {
enum Error {
NO_ERROR,
UNAUTHORIZED,
COMPTROLLER_MISMATCH,
INSUFFICIENT_SHORTFALL,
INSUFFICIENT_LIQUIDITY,
INVALID_CLOSE_FACTOR,
INVALID_COLLATERAL_FACTOR,
INVALID_LIQUIDATION_INCENTIVE,
MARKET_NOT_ENTERED, // no longer possible
MARKET_NOT_LISTED,
MARKET_ALREADY_LISTED,
MATH_ERROR,
NONZERO_BORROW_BALANCE,
PRICE_ERROR,
REJECTION,
SNAPSHOT_ERROR,
TOO_MANY_ASSETS,
TOO_MUCH_REPAY
}
enum FailureInfo {
ACCEPT_ADMIN_PENDING_ADMIN_CHECK,
ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK,
EXIT_MARKET_BALANCE_OWED,
EXIT_MARKET_REJECTION,
SET_CLOSE_FACTOR_OWNER_CHECK,
SET_CLOSE_FACTOR_VALIDATION,
SET_COLLATERAL_FACTOR_OWNER_CHECK,
SET_COLLATERAL_FACTOR_NO_EXISTS,
SET_COLLATERAL_FACTOR_VALIDATION,
SET_COLLATERAL_FACTOR_WITHOUT_PRICE,
SET_IMPLEMENTATION_OWNER_CHECK,
SET_LIQUIDATION_INCENTIVE_OWNER_CHECK,
SET_LIQUIDATION_INCENTIVE_VALIDATION,
SET_MAX_ASSETS_OWNER_CHECK,
SET_PENDING_ADMIN_OWNER_CHECK,
SET_PENDING_IMPLEMENTATION_OWNER_CHECK,
SET_PRICE_ORACLE_OWNER_CHECK,
SUPPORT_MARKET_EXISTS,
SUPPORT_MARKET_OWNER_CHECK,
SET_PAUSE_GUARDIAN_OWNER_CHECK
}
/**
* @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary
* contract-specific code that enables us to report opaque error codes from upgradeable contracts.
**/
event Failure(uint error, uint info, uint detail);
/**
* @dev use this when reporting a known error from the money market or a non-upgradeable collaborator
*/
function fail(Error err, FailureInfo info) internal returns (uint) {
emit Failure(uint(err), uint(info), 0);
return uint(err);
}
/**
* @dev use this when reporting an opaque error from an upgradeable collaborator contract
*/
function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) {
emit Failure(uint(err), uint(info), opaqueError);
return uint(err);
}
}
contract TokenErrorReporter {
uint public constant NO_ERROR = 0; // support legacy return codes
error TransferComptrollerRejection(uint256 errorCode);
error TransferNotAllowed();
error TransferNotEnough();
error TransferTooMuch();
error MintComptrollerRejection(uint256 errorCode);
error MintFreshnessCheck();
error RedeemComptrollerRejection(uint256 errorCode);
error RedeemFreshnessCheck();
error RedeemTransferOutNotPossible();
error BorrowComptrollerRejection(uint256 errorCode);
error BorrowFreshnessCheck();
error BorrowCashNotAvailable();
error RepayBorrowComptrollerRejection(uint256 errorCode);
error RepayBorrowFreshnessCheck();
error LiquidateComptrollerRejection(uint256 errorCode);
error LiquidateFreshnessCheck();
error LiquidateCollateralFreshnessCheck();
error LiquidateAccrueBorrowInterestFailed(uint256 errorCode);
error LiquidateAccrueCollateralInterestFailed(uint256 errorCode);
error LiquidateLiquidatorIsBorrower();
error LiquidateCloseAmountIsZero();
error LiquidateCloseAmountIsUintMax();
error LiquidateRepayBorrowFreshFailed(uint256 errorCode);
error LiquidateSeizeComptrollerRejection(uint256 errorCode);
error LiquidateSeizeLiquidatorIsBorrower();
error AcceptAdminPendingAdminCheck();
error SetComptrollerOwnerCheck();
error SetPendingAdminOwnerCheck();
error SetReserveFactorAdminCheck();
error SetReserveFactorFreshCheck();
error SetReserveFactorBoundsCheck();
error AddReservesFactorFreshCheck(uint256 actualAddAmount);
error ReduceReservesAdminCheck();
error ReduceReservesFreshCheck();
error ReduceReservesCashNotAvailable();
error ReduceReservesCashValidation();
error SetInterestRateModelOwnerCheck();
error SetInterestRateModelFreshCheck();
}
// File: contracts\CTokenInterfaces.sol
pragma solidity ^0.8.10;
contract CTokenStorage {
/**
* @dev Guard variable for re-entrancy checks
*/
bool internal _notEntered;
/**
* @notice EIP-20 token name for this token
*/
string public name;
/**
* @notice EIP-20 token symbol for this token
*/
string public symbol;
/**
* @notice EIP-20 token decimals for this token
*/
uint8 public decimals;
// Maximum borrow rate that can ever be applied (.0005% / block)
uint internal constant borrowRateMaxMantissa = 0.0005e16;
// Maximum fraction of interest that can be set aside for reserves
uint internal constant reserveFactorMaxMantissa = 1e18;
/**
* @notice Administrator for this contract
*/
address payable public admin;
/**
* @notice Pending administrator for this contract
*/
address payable public pendingAdmin;
/**
* @notice Contract which oversees inter-cToken operations
*/
ComptrollerInterface public comptroller;
/**
* @notice Model which tells what the current interest rate should be
*/
InterestRateModel public interestRateModel;
// Initial exchange rate used when minting the first CTokens (used when totalSupply = 0)
uint internal initialExchangeRateMantissa;
/**
* @notice Fraction of interest currently set aside for reserves
*/
uint public reserveFactorMantissa;
/**
* @notice Block number that interest was last accrued at
*/
uint public accrualBlockNumber;
/**
* @notice Accumulator of the total earned interest rate since the opening of the market
*/
uint public borrowIndex;
/**
* @notice Total amount of outstanding borrows of the underlying in this market
*/
uint public totalBorrows;
/**
* @notice Total amount of reserves of the underlying held in this market
*/
uint public totalReserves;
/**
* @notice Total number of tokens in circulation
*/
uint public totalSupply;
// Official record of token balances for each account
mapping (address => uint) internal accountTokens;
// Approved token transfer amounts on behalf of others
mapping (address => mapping (address => uint)) internal transferAllowances;
/**
* @notice Container for borrow balance information
* @member principal Total balance (with accrued interest), after applying the most recent balance-changing action
* @member interestIndex Global borrowIndex as of the most recent balance-changing action
*/
struct BorrowSnapshot {
uint principal;
uint interestIndex;
}
// Mapping of account addresses to outstanding borrow balances
mapping(address => BorrowSnapshot) internal accountBorrows;
/**
* @notice Share of seized collateral that is added to reserves
*/
uint public constant protocolSeizeShareMantissa = 2.8e16; //2.8%
}
abstract contract CTokenInterface is CTokenStorage {
/**
* @notice Indicator that this is a CToken contract (for inspection)
*/
bool public constant isCToken = true;
/*** Market Events ***/
/**
* @notice Event emitted when interest is accrued
*/
event AccrueInterest(uint cashPrior, uint interestAccumulated, uint borrowIndex, uint totalBorrows);
/**
* @notice Event emitted when tokens are minted
*/
event Mint(address minter, uint mintAmount, uint mintTokens);
/**
* @notice Event emitted when tokens are redeemed
*/
event Redeem(address redeemer, uint redeemAmount, uint redeemTokens);
/**
* @notice Event emitted when underlying is borrowed
*/
event Borrow(address borrower, uint borrowAmount, uint accountBorrows, uint totalBorrows);
/**
* @notice Event emitted when a borrow is repaid
*/
event RepayBorrow(address payer, address borrower, uint repayAmount, uint accountBorrows, uint totalBorrows);
/**
* @notice Event emitted when a borrow is liquidated
*/
event LiquidateBorrow(address liquidator, address borrower, uint repayAmount, address cTokenCollateral, uint seizeTokens);
/*** Admin Events ***/
/**
* @notice Event emitted when pendingAdmin is changed
*/
event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
/**
* @notice Event emitted when pendingAdmin is accepted, which means admin is updated
*/
event NewAdmin(address oldAdmin, address newAdmin);
/**
* @notice Event emitted when comptroller is changed
*/
event NewComptroller(ComptrollerInterface oldComptroller, ComptrollerInterface newComptroller);
/**
* @notice Event emitted when interestRateModel is changed
*/
event NewMarketInterestRateModel(InterestRateModel oldInterestRateModel, InterestRateModel newInterestRateModel);
/**
* @notice Event emitted when the reserve factor is changed
*/
event NewReserveFactor(uint oldReserveFactorMantissa, uint newReserveFactorMantissa);
/**
* @notice Event emitted when the reserves are added
*/
event ReservesAdded(address benefactor, uint addAmount, uint newTotalReserves);
/**
* @notice Event emitted when the reserves are reduced
*/
event ReservesReduced(address admin, uint reduceAmount, uint newTotalReserves);
/**
* @notice EIP20 Transfer event
*/
event Transfer(address indexed from, address indexed to, uint amount);
/**
* @notice EIP20 Approval event
*/
event Approval(address indexed owner, address indexed spender, uint amount);
/*** User Interface ***/
function transfer(address dst, uint amount) virtual external returns (bool);
function transferFrom(address src, address dst, uint amount) virtual external returns (bool);
function approve(address spender, uint amount) virtual external returns (bool);
function allowance(address owner, address spender) virtual external view returns (uint);
function balanceOf(address owner) virtual external view returns (uint);
function balanceOfUnderlying(address owner) virtual external returns (uint);
function getAccountSnapshot(address account) virtual external view returns (uint, uint, uint, uint);
function borrowRatePerBlock() virtual external view returns (uint);
function supplyRatePerBlock() virtual external view returns (uint);
function totalBorrowsCurrent() virtual external returns (uint);
function borrowBalanceCurrent(address account) virtual external returns (uint);
function borrowBalanceStored(address account) virtual external view returns (uint);
function exchangeRateCurrent() virtual external returns (uint);
function exchangeRateStored() virtual external view returns (uint);
function getCash() virtual external view returns (uint);
function accrueInterest() virtual external returns (uint);
function seize(address liquidator, address borrower, uint seizeTokens) virtual external returns (uint);
/*** Admin Functions ***/
function _setPendingAdmin(address payable newPendingAdmin) virtual external returns (uint);
function _acceptAdmin() virtual external returns (uint);
function _setComptroller(ComptrollerInterface newComptroller) virtual external returns (uint);
function _setReserveFactor(uint newReserveFactorMantissa) virtual external returns (uint);
function _reduceReserves(uint reduceAmount) virtual external returns (uint);
function _setInterestRateModel(InterestRateModel newInterestRateModel) virtual external returns (uint);
}
contract CErc20Storage {
/**
* @notice Underlying asset for this CToken
*/
address public underlying;
}
abstract contract CErc20Interface is CErc20Storage {
/*** User Interface ***/
function mint(uint mintAmount) virtual external returns (uint);
function redeem(uint redeemTokens) virtual external returns (uint);
function redeemUnderlying(uint redeemAmount) virtual external returns (uint);
function borrow(uint borrowAmount) virtual external returns (uint);
function repayBorrow(uint repayAmount) virtual external returns (uint);
function repayBorrowBehalf(address borrower, uint repayAmount) virtual external returns (uint);
function liquidateBorrow(address borrower, uint repayAmount, CTokenInterface cTokenCollateral) virtual external returns (uint);
function sweepToken(EIP20NonStandardInterface token) virtual external;
/*** Admin Functions ***/
function _addReserves(uint addAmount) virtual external returns (uint);
}
contract CDelegationStorage {
/**
* @notice Implementation address for this contract
*/
address public implementation;
}
abstract contract CDelegatorInterface is CDelegationStorage {
/**
* @notice Emitted when implementation is changed
*/
event NewImplementation(address oldImplementation, address newImplementation);
/**
* @notice Called by the admin to update the implementation of the delegator
* @param implementation_ The address of the new implementation for delegation
* @param allowResign Flag to indicate whether to call _resignImplementation on the old implementation
* @param becomeImplementationData The encoded bytes data to be passed to _becomeImplementation
*/
function _setImplementation(address implementation_, bool allowResign, bytes memory becomeImplementationData) virtual external;
}
abstract contract CDelegateInterface is CDelegationStorage {
/**
* @notice Called by the delegator on a delegate to initialize it for duty
* @dev Should revert if any issues arise which make it unfit for delegation
* @param data The encoded bytes data for any initialization
*/
function _becomeImplementation(bytes memory data) virtual external;
/**
* @notice Called by the delegator on a delegate to forfeit its responsibility
*/
function _resignImplementation() virtual external;
}
// File: contracts\EIP20Interface.sol
pragma solidity ^0.8.10;
/**
* @title ERC 20 Token Standard Interface
* https://eips.ethereum.org/EIPS/eip-20
*/
interface EIP20Interface {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
/**
* @notice Get the total number of tokens in circulation
* @return The supply of tokens
*/
function totalSupply() external view returns (uint256);
/**
* @notice Gets the balance of the specified address
* @param owner The address from which the balance will be retrieved
* @return balance The balance
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @notice Transfer `amount` tokens from `msg.sender` to `dst`
* @param dst The address of the destination account
* @param amount The number of tokens to transfer
* @return success Whether or not the transfer succeeded
*/
function transfer(address dst, uint256 amount) external returns (bool success);
/**
* @notice Transfer `amount` tokens from `src` to `dst`
* @param src The address of the source account
* @param dst The address of the destination account
* @param amount The number of tokens to transfer
* @return success Whether or not the transfer succeeded
*/
function transferFrom(address src, address dst, uint256 amount) external returns (bool success);
/**
* @notice Approve `spender` to transfer up to `amount` from `src`
* @dev This will overwrite the approval amount for `spender`
* and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
* @param spender The address of the account which may transfer tokens
* @param amount The number of tokens that are approved (-1 means infinite)
* @return success Whether or not the approval succeeded
*/
function approve(address spender, uint256 amount) external returns (bool success);
/**
* @notice Get the current allowance from `owner` for `spender`
* @param owner The address of the account which owns the tokens to be spent
* @param spender The address of the account which may transfer tokens
* @return remaining The number of tokens allowed to be spent (-1 means infinite)
*/
function allowance(address owner, address spender) external view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
}
// File: contracts\ExponentialNoError.sol
pragma solidity ^0.8.10;
/**
* @title Exponential module for storing fixed-precision decimals
* @author Compound
* @notice Exp is a struct which stores decimals with a fixed precision of 18 decimal places.
* Thus, if we wanted to store the 5.1, mantissa would store 5.1e18. That is:
* `Exp({mantissa: 5100000000000000000})`.
*/
contract ExponentialNoError {
uint constant expScale = 1e18;
uint constant doubleScale = 1e36;
uint constant halfExpScale = expScale/2;
uint constant mantissaOne = expScale;
struct Exp {
uint mantissa;
}
struct Double {
uint mantissa;
}
/**
* @dev Truncates the given exp to a whole number value.
* For example, truncate(Exp{mantissa: 15 * expScale}) = 15
*/
function truncate(Exp memory exp) pure internal returns (uint) {
// Note: We are not using careful math here as we're performing a division that cannot fail
return exp.mantissa / expScale;
}
/**
* @dev Multiply an Exp by a scalar, then truncate to return an unsigned integer.
*/
function mul_ScalarTruncate(Exp memory a, uint scalar) pure internal returns (uint) {
Exp memory product = mul_(a, scalar);
return truncate(product);
}
/**
* @dev Multiply an Exp by a scalar, truncate, then add an to an unsigned integer, returning an unsigned integer.
*/
function mul_ScalarTruncateAddUInt(Exp memory a, uint scalar, uint addend) pure internal returns (uint) {
Exp memory product = mul_(a, scalar);
return add_(truncate(product), addend);
}
/**
* @dev Checks if first Exp is less than second Exp.
*/
function lessThanExp(Exp memory left, Exp memory right) pure internal returns (bool) {
return left.mantissa < right.mantissa;
}
/**
* @dev Checks if left Exp <= right Exp.
*/
function lessThanOrEqualExp(Exp memory left, Exp memory right) pure internal returns (bool) {
return left.mantissa <= right.mantissa;
}
/**
* @dev Checks if left Exp > right Exp.
*/
function greaterThanExp(Exp memory left, Exp memory right) pure internal returns (bool) {
return left.mantissa > right.mantissa;
}
/**
* @dev returns true if Exp is exactly zero
*/
function isZeroExp(Exp memory value) pure internal returns (bool) {
return value.mantissa == 0;
}
function safe224(uint n, string memory errorMessage) pure internal returns (uint224) {
require(n < 2**224, errorMessage);
return uint224(n);
}
function safe32(uint n, string memory errorMessage) pure internal returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function add_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
return Exp({mantissa: add_(a.mantissa, b.mantissa)});
}
function add_(Double memory a, Double memory b) pure internal returns (Double memory) {
return Double({mantissa: add_(a.mantissa, b.mantissa)});
}
function add_(uint a, uint b) pure internal returns (uint) {
return a + b;
}
function sub_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
return Exp({mantissa: sub_(a.mantissa, b.mantissa)});
}
function sub_(Double memory a, Double memory b) pure internal returns (Double memory) {
return Double({mantissa: sub_(a.mantissa, b.mantissa)});
}
function sub_(uint a, uint b) pure internal returns (uint) {
return a - b;
}
function mul_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
return Exp({mantissa: mul_(a.mantissa, b.mantissa) / expScale});
}
function mul_(Exp memory a, uint b) pure internal returns (Exp memory) {
return Exp({mantissa: mul_(a.mantissa, b)});
}
function mul_(uint a, Exp memory b) pure internal returns (uint) {
return mul_(a, b.mantissa) / expScale;
}
function mul_(Double memory a, Double memory b) pure internal returns (Double memory) {
return Double({mantissa: mul_(a.mantissa, b.mantissa) / doubleScale});
}
function mul_(Double memory a, uint b) pure internal returns (Double memory) {
return Double({mantissa: mul_(a.mantissa, b)});
}
function mul_(uint a, Double memory b) pure internal returns (uint) {
return mul_(a, b.mantissa) / doubleScale;
}
function mul_(uint a, uint b) pure internal returns (uint) {
return a * b;
}
function div_(Exp memory a, Exp memory b) pure internal returns (Exp memory) {
return Exp({mantissa: div_(mul_(a.mantissa, expScale), b.mantissa)});
}
function div_(Exp memory a, uint b) pure internal returns (Exp memory) {
return Exp({mantissa: div_(a.mantissa, b)});
}
function div_(uint a, Exp memory b) pure internal returns (uint) {
return div_(mul_(a, expScale), b.mantissa);
}
function div_(Double memory a, Double memory b) pure internal returns (Double memory) {
return Double({mantissa: div_(mul_(a.mantissa, doubleScale), b.mantissa)});
}
function div_(Double memory a, uint b) pure internal returns (Double memory) {
return Double({mantissa: div_(a.mantissa, b)});
}
function div_(uint a, Double memory b) pure internal returns (uint) {
return div_(mul_(a, doubleScale), b.mantissa);
}
function div_(uint a, uint b) pure internal returns (uint) {
return a / b;
}
function fraction(uint a, uint b) pure internal returns (Double memory) {
return Double({mantissa: div_(mul_(a, doubleScale), b)});
}
}
// File: contracts\CToken.sol
pragma solidity ^0.8.10;
/**
* @title Compound's CToken Contract
* @notice Abstract base for CTokens
* @author Compound
*/
abstract contract CToken is
CTokenInterface,
ExponentialNoError,
TokenErrorReporter
{
/**
* @notice Initialize the money market
* @param comptroller_ The address of the Comptroller
* @param interestRateModel_ The address of the interest rate model
* @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18
* @param name_ EIP-20 name of this token
* @param symbol_ EIP-20 symbol of this token
* @param decimals_ EIP-20 decimal precision of this token
*/
function initialize(
ComptrollerInterface comptroller_,
InterestRateModel interestRateModel_,
uint256 initialExchangeRateMantissa_,
string memory name_,
string memory symbol_,
uint8 decimals_
) public {
require(msg.sender == admin, "only admin may initialize the market");
require(
accrualBlockNumber == 0 && borrowIndex == 0,
"market may only be initialized once"
);
// Set initial exchange rate
initialExchangeRateMantissa = initialExchangeRateMantissa_;
require(
initialExchangeRateMantissa > 0,
"initial exchange rate must be greater than zero."
);
// Set the comptroller
uint256 err = _setComptroller(comptroller_);
require(err == NO_ERROR, "setting comptroller failed");
// Initialize block number and borrow index (block number mocks depend on comptroller being set)
accrualBlockNumber = getBlockNumber();
borrowIndex = mantissaOne;
// Set the interest rate model (depends on block number / borrow index)
err = _setInterestRateModelFresh(interestRateModel_);
require(err == NO_ERROR, "setting interest rate model failed");
name = name_;
symbol = symbol_;
decimals = decimals_;
// The counter starts true to prevent changing it from zero to non-zero (i.e. smaller cost/refund)
_notEntered = true;
}
/**
* @notice Transfer `tokens` tokens from `src` to `dst` by `spender`
* @dev Called by both `transfer` and `transferFrom` internally
* @param spender The address of the account performing the transfer
* @param src The address of the source account
* @param dst The address of the destination account
* @param tokens The number of tokens to transfer
* @return 0 if the transfer succeeded, else revert
*/
function transferTokens(
address spender,
address src,
address dst,
uint256 tokens
) internal returns (uint256) {
/* Fail if transfer not allowed */
uint256 allowed = comptroller.transferAllowed(
address(this),
src,
dst,
tokens
);
if (allowed != 0) {
revert TransferComptrollerRejection(allowed);
}
/* Do not allow self-transfers */
if (src == dst) {
revert TransferNotAllowed();
}
/* Get the allowance, infinite for the account owner */
uint256 startingAllowance = 0;
if (spender == src) {
startingAllowance = type(uint256).max;
} else {
startingAllowance = transferAllowances[src][spender];
}
/* Do the calculations, checking for {under,over}flow */
uint256 allowanceNew = startingAllowance - tokens;
uint256 srcTokensNew = accountTokens[src] - tokens;
uint256 dstTokensNew = accountTokens[dst] + tokens;
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
accountTokens[src] = srcTokensNew;
accountTokens[dst] = dstTokensNew;
/* Eat some of the allowance (if necessary) */
if (startingAllowance != type(uint256).max) {
transferAllowances[src][spender] = allowanceNew;
}
/* We emit a Transfer event */
emit Transfer(src, dst, tokens);
// unused function
// comptroller.transferVerify(address(this), src, dst, tokens);
return NO_ERROR;
}
/**
* @notice Transfer `amount` tokens from `msg.sender` to `dst`
* @param dst The address of the destination account
* @param amount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transfer(address dst, uint256 amount)
external
override
nonReentrant
returns (bool)
{
return transferTokens(msg.sender, msg.sender, dst, amount) == NO_ERROR;
}
/**
* @notice Transfer `amount` tokens from `src` to `dst`
* @param src The address of the source account
* @param dst The address of the destination account
* @param amount The number of tokens to transfer
* @return Whether or not the transfer succeeded
*/
function transferFrom(
address src,
address dst,
uint256 amount
) external override nonReentrant returns (bool) {
return transferTokens(msg.sender, src, dst, amount) == NO_ERROR;
}
/**
* @notice Approve `spender` to transfer up to `amount` from `src`
* @dev This will overwrite the approval amount for `spender`
* and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
* @param spender The address of the account which may transfer tokens
* @param amount The number of tokens that are approved (uint256.max means infinite)
* @return Whether or not the approval succeeded
*/
function approve(address spender, uint256 amount)
external
override
returns (bool)
{
address src = msg.sender;
transferAllowances[src][spender] = amount;
emit Approval(src, spender, amount);
return true;
}
/**
* @notice Get the current allowance from `owner` for `spender`
* @param owner The address of the account which owns the tokens to be spent
* @param spender The address of the account which may transfer tokens
* @return The number of tokens allowed to be spent (-1 means infinite)
*/
function allowance(address owner, address spender)
external
view
override
returns (uint256)
{
return transferAllowances[owner][spender];
}
/**
* @notice Get the token balance of the `owner`
* @param owner The address of the account to query
* @return The number of tokens owned by `owner`
*/
function balanceOf(address owner) external view override returns (uint256) {
return accountTokens[owner];
}
/**
* @notice Get the underlying balance of the `owner`
* @dev This also accrues interest in a transaction
* @param owner The address of the account to query
* @return The amount of underlying owned by `owner`
*/
function balanceOfUnderlying(address owner)
external
override
returns (uint256)
{
Exp memory exchangeRate = Exp({mantissa: exchangeRateCurrent()});
return mul_ScalarTruncate(exchangeRate, accountTokens[owner]);
}
/**
* @notice Get a snapshot of the account's balances, and the cached exchange rate
* @dev This is used by comptroller to more efficiently perform liquidity checks.
* @param account Address of the account to snapshot
* @return (possible error, token balance, borrow balance, exchange rate mantissa)
*/
function getAccountSnapshot(address account)
external
view
override
returns (
uint256,
uint256,
uint256,
uint256
)
{
return (
NO_ERROR,
accountTokens[account],
borrowBalanceStoredInternal(account),
exchangeRateStoredInternal()
);
}
/**
* @dev Function to simply retrieve block number
* This exists mainly for inheriting test contracts to stub this result.
*/
function getBlockNumber() internal view virtual returns (uint256) {
return block.timestamp;
}
/**
* @notice Returns the current per-block borrow interest rate for this cToken
* @return The borrow interest rate per block, scaled by 1e18
*/
function borrowRatePerBlock() external view override returns (uint256) {
return
interestRateModel.getBorrowRate(
getCashPrior(),
totalBorrows,
totalReserves
);
}
/**
* @notice Returns the current per-block supply interest rate for this cToken
* @return The supply interest rate per block, scaled by 1e18
*/
function supplyRatePerBlock() external view override returns (uint256) {
return
interestRateModel.getSupplyRate(
getCashPrior(),
totalBorrows,
totalReserves,
reserveFactorMantissa
);
}
/**
* @notice Returns the current total borrows plus accrued interest
* @return The total borrows with interest
*/
function totalBorrowsCurrent()
external
override
nonReentrant
returns (uint256)
{
accrueInterest();
return totalBorrows;
}
/**
* @notice Accrue interest to updated borrowIndex and then calculate account's borrow balance using the updated borrowIndex
* @param account The address whose balance should be calculated after updating borrowIndex
* @return The calculated balance
*/
function borrowBalanceCurrent(address account)
external
override
nonReentrant
returns (uint256)
{
accrueInterest();
return borrowBalanceStored(account);
}
/**
* @notice Return the borrow balance of account based on stored data
* @param account The address whose balance should be calculated
* @return The calculated balance
*/
function borrowBalanceStored(address account)
public
view
override
returns (uint256)
{
return borrowBalanceStoredInternal(account);
}
/**
* @notice Return the borrow balance of account based on stored data
* @param account The address whose balance should be calculated
* @return (error code, the calculated balance or 0 if error code is non-zero)
*/
function borrowBalanceStoredInternal(address account)
internal
view
returns (uint256)
{
/* Get borrowBalance and borrowIndex */
BorrowSnapshot storage borrowSnapshot = accountBorrows[account];
/* If borrowBalance = 0 then borrowIndex is likely also 0.
* Rather than failing the calculation with a division by 0, we immediately return 0 in this case.
*/
if (borrowSnapshot.principal == 0) {
return 0;
}
/* Calculate new borrow balance using the interest index:
* recentBorrowBalance = borrower.borrowBalance * market.borrowIndex / borrower.borrowIndex
*/
uint256 principalTimesIndex = borrowSnapshot.principal * borrowIndex;
return principalTimesIndex / borrowSnapshot.interestIndex;
}
/**
* @notice Accrue interest then return the up-to-date exchange rate
* @return Calculated exchange rate scaled by 1e18
*/
function exchangeRateCurrent()
public
override
nonReentrant
returns (uint256)
{
accrueInterest();
return exchangeRateStored();
}
/**
* @notice Calculates the exchange rate from the underlying to the CToken
* @dev This function does not accrue interest before calculating the exchange rate
* @return Calculated exchange rate scaled by 1e18
*/
function exchangeRateStored() public view override returns (uint256) {
return exchangeRateStoredInternal();
}
/**
* @notice Calculates the exchange rate from the underlying to the CToken
* @dev This function does not accrue interest before calculating the exchange rate
* @return calculated exchange rate scaled by 1e18
*/
function exchangeRateStoredInternal()
internal
view
virtual
returns (uint256)
{
uint256 _totalSupply = totalSupply;
if (_totalSupply == 0) {
/*
* If there are no tokens minted:
* exchangeRate = initialExchangeRate
*/
return initialExchangeRateMantissa;
} else {
/*
* Otherwise:
* exchangeRate = (totalCash + totalBorrows - totalReserves) / totalSupply
*/
uint256 totalCash = getCashPrior();
uint256 cashPlusBorrowsMinusReserves = totalCash +
totalBorrows -
totalReserves;
uint256 exchangeRate = (cashPlusBorrowsMinusReserves * expScale) /
_totalSupply;
return exchangeRate;
}
}
/**
* @notice Get cash balance of this cToken in the underlying asset
* @return The quantity of underlying asset owned by this contract
*/
function getCash() external view override returns (uint256) {
return getCashPrior();
}
/**
* @notice Applies accrued interest to total borrows and reserves
* @dev This calculates interest accrued from the last checkpointed block
* up to the current block and writes new checkpoint to storage.
*/
function accrueInterest() public virtual override returns (uint256) {
/* Remember the initial block number */
uint256 currentBlockNumber = getBlockNumber();
uint256 accrualBlockNumberPrior = accrualBlockNumber;
/* Short-circuit accumulating 0 interest */
if (accrualBlockNumberPrior == currentBlockNumber) {
return NO_ERROR;
}
/* Read the previous values out of storage */
uint256 cashPrior = getCashPrior();
uint256 borrowsPrior = totalBorrows;
uint256 reservesPrior = totalReserves;
uint256 borrowIndexPrior = borrowIndex;
/* Calculate the current borrow interest rate */
uint256 borrowRateMantissa = interestRateModel.getBorrowRate(
cashPrior,
borrowsPrior,
reservesPrior
);
require(
borrowRateMantissa <= borrowRateMaxMantissa,
"borrow rate is absurdly high"
);
/* Calculate the number of blocks elapsed since the last accrual */
uint256 blockDelta = currentBlockNumber - accrualBlockNumberPrior;
/*
* Calculate the interest accumulated into borrows and reserves and the new index:
* simpleInterestFactor = borrowRate * blockDelta
* interestAccumulated = simpleInterestFactor * totalBorrows
* totalBorrowsNew = interestAccumulated + totalBorrows
* totalReservesNew = interestAccumulated * reserveFactor + totalReserves
* borrowIndexNew = simpleInterestFactor * borrowIndex + borrowIndex
*/
Exp memory simpleInterestFactor = mul_(
Exp({mantissa: borrowRateMantissa}),
blockDelta
);
uint256 interestAccumulated = mul_ScalarTruncate(
simpleInterestFactor,
borrowsPrior
);
uint256 totalBorrowsNew = interestAccumulated + borrowsPrior;
uint256 totalReservesNew = mul_ScalarTruncateAddUInt(
Exp({mantissa: reserveFactorMantissa}),
interestAccumulated,
reservesPrior
);
uint256 borrowIndexNew = mul_ScalarTruncateAddUInt(
simpleInterestFactor,
borrowIndexPrior,
borrowIndexPrior
);
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
/* We write the previously calculated values into storage */
accrualBlockNumber = currentBlockNumber;
borrowIndex = borrowIndexNew;
totalBorrows = totalBorrowsNew;
totalReserves = totalReservesNew;
/* We emit an AccrueInterest event */
emit AccrueInterest(
cashPrior,
interestAccumulated,
borrowIndexNew,
totalBorrowsNew
);
return NO_ERROR;
}
/**
* @notice Sender supplies assets into the market and receives cTokens in exchange
* @dev Accrues interest whether or not the operation succeeds, unless reverted
* @param mintAmount The amount of the underlying asset to supply
*/
function mintInternal(uint256 mintAmount) internal nonReentrant {
accrueInterest();
// mintFresh emits the actual Mint event if successful and logs on errors, so we don't need to
mintFresh(msg.sender, mintAmount);
}
/**
* @notice User supplies assets into the market and receives cTokens in exchange
* @dev Assumes interest has already been accrued up to the current block
* @param minter The address of the account which is supplying the assets
* @param mintAmount The amount of the underlying asset to supply
*/
function mintFresh(address minter, uint256 mintAmount) internal {
/* Fail if mint not allowed */
uint256 allowed = comptroller.mintAllowed(
address(this),
minter,
mintAmount
);
if (allowed != 0) {
revert MintComptrollerRejection(allowed);
}
/* Verify market's block number equals current block number */
if (accrualBlockNumber != getBlockNumber()) {
revert MintFreshnessCheck();
}
Exp memory exchangeRate = Exp({mantissa: exchangeRateStoredInternal()});
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
/*
* We call `doTransferIn` for the minter and the mintAmount.
* Note: The cToken must handle variations between ERC-20 and ETH underlying.
* `doTransferIn` reverts if anything goes wrong, since we can't be sure if
* side-effects occurred. The function returns the amount actually transferred,
* in case of a fee. On success, the cToken holds an additional `actualMintAmount`
* of cash.
*/
uint256 actualMintAmount = doTransferIn(minter, mintAmount);
/*
* We get the current exchange rate and calculate the number of cTokens to be minted:
* mintTokens = actualMintAmount / exchangeRate
*/
uint256 mintTokens = div_(actualMintAmount, exchangeRate);
/*
* We calculate the new total supply of cTokens and minter token balance, checking for overflow:
* totalSupplyNew = totalSupply + mintTokens
* accountTokensNew = accountTokens[minter] + mintTokens
* And write them into storage
*/
totalSupply = totalSupply + mintTokens;
accountTokens[minter] = accountTokens[minter] + mintTokens;
/* We emit a Mint event, and a Transfer event */
emit Mint(minter, actualMintAmount, mintTokens);
emit Transfer(address(this), minter, mintTokens);
/* We call the defense hook */
// unused function
// comptroller.mintVerify(address(this), minter, actualMintAmount, mintTokens);
}
/**
* @notice Sender redeems cTokens in exchange for the underlying asset
* @dev Accrues interest whether or not the operation succeeds, unless reverted
* @param redeemTokens The number of cTokens to redeem into underlying
*/
function redeemInternal(uint256 redeemTokens) internal nonReentrant {
accrueInterest();
// redeemFresh emits redeem-specific logs on errors, so we don't need to
redeemFresh(payable(msg.sender), redeemTokens, 0);
}
/**
* @notice Sender redeems cTokens in exchange for a specified amount of underlying asset
* @dev Accrues interest whether or not the operation succeeds, unless reverted
* @param redeemAmount The amount of underlying to receive from redeeming cTokens
*/
function redeemUnderlyingInternal(uint256 redeemAmount)
internal
nonReentrant
{
accrueInterest();
// redeemFresh emits redeem-specific logs on errors, so we don't need to
redeemFresh(payable(msg.sender), 0, redeemAmount);
}
/**
* @notice User redeems cTokens in exchange for the underlying asset
* @dev Assumes interest has already been accrued up to the current block
* @param redeemer The address of the account which is redeeming the tokens
* @param redeemTokensIn The number of cTokens to redeem into underlying (only one of redeemTokensIn or redeemAmountIn may be non-zero)
* @param redeemAmountIn The number of underlying tokens to receive from redeeming cTokens (only one of redeemTokensIn or redeemAmountIn may be non-zero)
*/
function redeemFresh(
address payable redeemer,
uint256 redeemTokensIn,
uint256 redeemAmountIn
) internal {
require(
redeemTokensIn == 0 || redeemAmountIn == 0,
"one of redeemTokensIn or redeemAmountIn must be zero"
);
/* exchangeRate = invoke Exchange Rate Stored() */
Exp memory exchangeRate = Exp({mantissa: exchangeRateStoredInternal()});
uint256 redeemTokens;
uint256 redeemAmount;
/* If redeemTokensIn > 0: */
if (redeemTokensIn > 0) {
/*
* We calculate the exchange rate and the amount of underlying to be redeemed:
* redeemTokens = redeemTokensIn
* redeemAmount = redeemTokensIn x exchangeRateCurrent
*/
redeemTokens = redeemTokensIn;
redeemAmount = mul_ScalarTruncate(exchangeRate, redeemTokensIn);
} else {
/*
* We get the current exchange rate and calculate the amount to be redeemed:
* redeemTokens = redeemAmountIn / exchangeRate
* redeemAmount = redeemAmountIn
*/
redeemTokens = div_(redeemAmountIn, exchangeRate);
redeemAmount = redeemAmountIn;
}
/* Fail if redeem not allowed */
uint256 allowed = comptroller.redeemAllowed(
address(this),
redeemer,
redeemTokens
);
if (allowed != 0) {
revert RedeemComptrollerRejection(allowed);
}
/* Verify market's block number equals current block number */
if (accrualBlockNumber != getBlockNumber()) {
revert RedeemFreshnessCheck();
}
/* Fail gracefully if protocol has insufficient cash */
if (getCashPrior() < redeemAmount) {
revert RedeemTransferOutNotPossible();
}
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
/*
* We write the previously calculated values into storage.
* Note: Avoid token reentrancy attacks by writing reduced supply before external transfer.
*/
totalSupply = totalSupply - redeemTokens;
accountTokens[redeemer] = accountTokens[redeemer] - redeemTokens;
/*
* We invoke doTransferOut for the redeemer and the redeemAmount.
* Note: The cToken must handle variations between ERC-20 and ETH underlying.
* On success, the cToken has redeemAmount less of cash.
* doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.
*/
doTransferOut(redeemer, redeemAmount);
/* We emit a Transfer event, and a Redeem event */
emit Transfer(redeemer, address(this), redeemTokens);
emit Redeem(redeemer, redeemAmount, redeemTokens);
/* We call the defense hook */
comptroller.redeemVerify(
address(this),
redeemer,
redeemAmount,
redeemTokens
);
}
/**
* @notice Sender borrows assets from the protocol to their own address
* @param borrowAmount The amount of the underlying asset to borrow
*/
function borrowInternal(uint256 borrowAmount) internal nonReentrant {
accrueInterest();
// borrowFresh emits borrow-specific logs on errors, so we don't need to
borrowFresh(payable(msg.sender), borrowAmount);
}
/**
* @notice Users borrow assets from the protocol to their own address
* @param borrowAmount The amount of the underlying asset to borrow
*/
function borrowFresh(address payable borrower, uint256 borrowAmount)
internal
{
/* Fail if borrow not allowed */
uint256 allowed = comptroller.borrowAllowed(
address(this),
borrower,
borrowAmount
);
if (allowed != 0) {
revert BorrowComptrollerRejection(allowed);
}
/* Verify market's block number equals current block number */
if (accrualBlockNumber != getBlockNumber()) {
revert BorrowFreshnessCheck();
}
/* Fail gracefully if protocol has insufficient underlying cash */
if (getCashPrior() < borrowAmount) {
revert BorrowCashNotAvailable();
}
/*
* We calculate the new borrower and total borrow balances, failing on overflow:
* accountBorrowNew = accountBorrow + borrowAmount
* totalBorrowsNew = totalBorrows + borrowAmount
*/
uint256 accountBorrowsPrev = borrowBalanceStoredInternal(borrower);
uint256 accountBorrowsNew = accountBorrowsPrev + borrowAmount;
uint256 totalBorrowsNew = totalBorrows + borrowAmount;
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
/*
* We write the previously calculated values into storage.
* Note: Avoid token reentrancy attacks by writing increased borrow before external transfer.
`*/
accountBorrows[borrower].principal = accountBorrowsNew;
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = totalBorrowsNew;
/*
* We invoke doTransferOut for the borrower and the borrowAmount.
* Note: The cToken must handle variations between ERC-20 and ETH underlying.
* On success, the cToken borrowAmount less of cash.
* doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.
*/
doTransferOut(borrower, borrowAmount);
/* We emit a Borrow event */
emit Borrow(borrower, borrowAmount, accountBorrowsNew, totalBorrowsNew);
}
/**
* @notice Sender repays their own borrow
* @param repayAmount The amount to repay, or -1 for the full outstanding amount
*/
function repayBorrowInternal(uint256 repayAmount) internal nonReentrant {
accrueInterest();
// repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to
repayBorrowFresh(msg.sender, msg.sender, repayAmount);
}
/**
* @notice Sender repays a borrow belonging to borrower
* @param borrower the account with the debt being payed off
* @param repayAmount The amount to repay, or -1 for the full outstanding amount
*/
function repayBorrowBehalfInternal(address borrower, uint256 repayAmount)
internal
nonReentrant
{
accrueInterest();
// repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to
repayBorrowFresh(msg.sender, borrower, repayAmount);
}
/**
* @notice Borrows are repaid by another user (possibly the borrower).
* @param payer the account paying off the borrow
* @param borrower the account with the debt being payed off
* @param repayAmount the amount of underlying tokens being returned, or -1 for the full outstanding amount
* @return (uint) the actual repayment amount.
*/
function repayBorrowFresh(
address payer,
address borrower,
uint256 repayAmount
) internal returns (uint256) {
/* Fail if repayBorrow not allowed */
uint256 allowed = comptroller.repayBorrowAllowed(
address(this),
payer,
borrower,
repayAmount
);
if (allowed != 0) {
revert RepayBorrowComptrollerRejection(allowed);
}
/* Verify market's block number equals current block number */
if (accrualBlockNumber != getBlockNumber()) {
revert RepayBorrowFreshnessCheck();
}
/* We fetch the amount the borrower owes, with accumulated interest */
uint256 accountBorrowsPrev = borrowBalanceStoredInternal(borrower);
/* If repayAmount == -1, repayAmount = accountBorrows */
uint256 repayAmountFinal = repayAmount == type(uint256).max
? accountBorrowsPrev
: repayAmount;
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
/*
* We call doTransferIn for the payer and the repayAmount
* Note: The cToken must handle variations between ERC-20 and ETH underlying.
* On success, the cToken holds an additional repayAmount of cash.
* doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred.
* it returns the amount actually transferred, in case of a fee.
*/
uint256 actualRepayAmount = doTransferIn(payer, repayAmountFinal);
/*
* We calculate the new borrower and total borrow balances, failing on underflow:
* accountBorrowsNew = accountBorrows - actualRepayAmount
* totalBorrowsNew = totalBorrows - actualRepayAmount
*/
uint256 accountBorrowsNew = accountBorrowsPrev - actualRepayAmount;
uint256 totalBorrowsNew = totalBorrows - actualRepayAmount;
/* We write the previously calculated values into storage */
accountBorrows[borrower].principal = accountBorrowsNew;
accountBorrows[borrower].interestIndex = borrowIndex;
totalBorrows = totalBorrowsNew;
/* We emit a RepayBorrow event */
emit RepayBorrow(
payer,
borrower,
actualRepayAmount,
accountBorrowsNew,
totalBorrowsNew
);
return actualRepayAmount;
}
/**
* @notice The sender liquidates the borrowers collateral.
* The collateral seized is transferred to the liquidator.
* @param borrower The borrower of this cToken to be liquidated
* @param cTokenCollateral The market in which to seize collateral from the borrower
* @param repayAmount The amount of the underlying borrowed asset to repay
*/
function liquidateBorrowInternal(
address borrower,
uint256 repayAmount,
CTokenInterface cTokenCollateral
) internal nonReentrant {
accrueInterest();
uint256 error = cTokenCollateral.accrueInterest();
if (error != NO_ERROR) {
// accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed
revert LiquidateAccrueCollateralInterestFailed(error);
}
// liquidateBorrowFresh emits borrow-specific logs on errors, so we don't need to
liquidateBorrowFresh(
msg.sender,
borrower,
repayAmount,
cTokenCollateral
);
}
/**
* @notice The liquidator liquidates the borrowers collateral.
* The collateral seized is transferred to the liquidator.
* @param borrower The borrower of this cToken to be liquidated
* @param liquidator The address repaying the borrow and seizing collateral
* @param cTokenCollateral The market in which to seize collateral from the borrower
* @param repayAmount The amount of the underlying borrowed asset to repay
*/
function liquidateBorrowFresh(
address liquidator,
address borrower,
uint256 repayAmount,
CTokenInterface cTokenCollateral
) internal {
/* Fail if liquidate not allowed */
uint256 allowed = comptroller.liquidateBorrowAllowed(
address(this),
address(cTokenCollateral),
liquidator,
borrower,
repayAmount
);
if (allowed != 0) {
revert LiquidateComptrollerRejection(allowed);
}
/* Verify market's block number equals current block number */
if (accrualBlockNumber != getBlockNumber()) {
revert LiquidateFreshnessCheck();
}
/* Verify cTokenCollateral market's block number equals current block number */
if (cTokenCollateral.accrualBlockNumber() != getBlockNumber()) {
revert LiquidateCollateralFreshnessCheck();
}
/* Fail if borrower = liquidator */
if (borrower == liquidator) {
revert LiquidateLiquidatorIsBorrower();
}
/* Fail if repayAmount = 0 */
if (repayAmount == 0) {
revert LiquidateCloseAmountIsZero();
}
/* Fail if repayAmount = -1 */
if (repayAmount == type(uint256).max) {
revert LiquidateCloseAmountIsUintMax();
}
/* Fail if repayBorrow fails */
uint256 actualRepayAmount = repayBorrowFresh(
liquidator,
borrower,
repayAmount
);
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
/* We calculate the number of collateral tokens that will be seized */
(uint256 amountSeizeError, uint256 seizeTokens) = comptroller
.liquidateCalculateSeizeTokens(
address(this),
address(cTokenCollateral),
actualRepayAmount
);
require(
amountSeizeError == NO_ERROR,
"LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED"
);
/* Revert if borrower collateral token balance < seizeTokens */
require(
cTokenCollateral.balanceOf(borrower) >= seizeTokens,
"LIQUIDATE_SEIZE_TOO_MUCH"
);
// If this is also the collateral, run seizeInternal to avoid re-entrancy, otherwise make an external call
if (address(cTokenCollateral) == address(this)) {
seizeInternal(address(this), liquidator, borrower, seizeTokens);
} else {
require(
cTokenCollateral.seize(liquidator, borrower, seizeTokens) ==
NO_ERROR,
"token seizure failed"
);
}
/* We emit a LiquidateBorrow event */
emit LiquidateBorrow(
liquidator,
borrower,
actualRepayAmount,
address(cTokenCollateral),
seizeTokens
);
}
/**
* @notice Transfers collateral tokens (this market) to the liquidator.
* @dev Will fail unless called by another cToken during the process of liquidation.
* Its absolutely critical to use msg.sender as the borrowed cToken and not a parameter.
* @param liquidator The account receiving seized collateral
* @param borrower The account having collateral seized
* @param seizeTokens The number of cTokens to seize
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function seize(
address liquidator,
address borrower,
uint256 seizeTokens
) external override nonReentrant returns (uint256) {
seizeInternal(msg.sender, liquidator, borrower, seizeTokens);
return NO_ERROR;
}
/**
* @notice Transfers collateral tokens (this market) to the liquidator.
* @dev Called only during an in-kind liquidation, or by liquidateBorrow during the liquidation of another CToken.
* Its absolutely critical to use msg.sender as the seizer cToken and not a parameter.
* @param seizerToken The contract seizing the collateral (i.e. borrowed cToken)
* @param liquidator The account receiving seized collateral
* @param borrower The account having collateral seized
* @param seizeTokens The number of cTokens to seize
*/
function seizeInternal(
address seizerToken,
address liquidator,
address borrower,
uint256 seizeTokens
) internal {
/* Fail if seize not allowed */
uint256 allowed = comptroller.seizeAllowed(
address(this),
seizerToken,
liquidator,
borrower,
seizeTokens
);
if (allowed != 0) {
revert LiquidateSeizeComptrollerRejection(allowed);
}
/* Fail if borrower = liquidator */
if (borrower == liquidator) {
revert LiquidateSeizeLiquidatorIsBorrower();
}
/*
* We calculate the new borrower and liquidator token balances, failing on underflow/overflow:
* borrowerTokensNew = accountTokens[borrower] - seizeTokens
* liquidatorTokensNew = accountTokens[liquidator] + seizeTokens
*/
uint256 protocolSeizeTokens = mul_(
seizeTokens,
Exp({mantissa: protocolSeizeShareMantissa})
);
uint256 liquidatorSeizeTokens = seizeTokens - protocolSeizeTokens;
Exp memory exchangeRate = Exp({mantissa: exchangeRateStoredInternal()});
uint256 protocolSeizeAmount = mul_ScalarTruncate(
exchangeRate,
protocolSeizeTokens
);
uint256 totalReservesNew = totalReserves + protocolSeizeAmount;
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
/* We write the calculated values into storage */
totalReserves = totalReservesNew;
totalSupply = totalSupply - protocolSeizeTokens;
accountTokens[borrower] = accountTokens[borrower] - seizeTokens;
accountTokens[liquidator] =
accountTokens[liquidator] +
liquidatorSeizeTokens;
/* Emit a Transfer event */
emit Transfer(borrower, liquidator, liquidatorSeizeTokens);
emit Transfer(borrower, address(this), protocolSeizeTokens);
emit ReservesAdded(
address(this),
protocolSeizeAmount,
totalReservesNew
);
}
/*** Admin Functions ***/
/**
* @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.
* @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.
* @param newPendingAdmin New pending admin.
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _setPendingAdmin(address payable newPendingAdmin)
external
override
returns (uint256)
{
// Check caller = admin
if (msg.sender != admin) {
revert SetPendingAdminOwnerCheck();
}
// Save current value, if any, for inclusion in log
address oldPendingAdmin = pendingAdmin;
// Store pendingAdmin with value newPendingAdmin
pendingAdmin = newPendingAdmin;
// Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)
emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);
return NO_ERROR;
}
/**
* @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin
* @dev Admin function for pending admin to accept role and update admin
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _acceptAdmin() external override returns (uint256) {
// Check caller is pendingAdmin and pendingAdmin 锟斤拷 address(0)
if (msg.sender != pendingAdmin || msg.sender == address(0)) {
revert AcceptAdminPendingAdminCheck();
}
// Save current values for inclusion in log
address oldAdmin = admin;
address oldPendingAdmin = pendingAdmin;
// Store admin with value pendingAdmin
admin = pendingAdmin;
// Clear the pending value
pendingAdmin = payable(address(0));
emit NewAdmin(oldAdmin, admin);
emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);
return NO_ERROR;
}
/**
* @notice Sets a new comptroller for the market
* @dev Admin function to set a new comptroller
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _setComptroller(ComptrollerInterface newComptroller)
public
override
returns (uint256)
{
// Check caller is admin
if (msg.sender != admin) {
revert SetComptrollerOwnerCheck();
}
ComptrollerInterface oldComptroller = comptroller;
// Ensure invoke comptroller.isComptroller() returns true
require(newComptroller.isComptroller(), "marker method returned false");
// Set market's comptroller to newComptroller
comptroller = newComptroller;
// Emit NewComptroller(oldComptroller, newComptroller)
emit NewComptroller(oldComptroller, newComptroller);
return NO_ERROR;
}
/**
* @notice accrues interest and sets a new reserve factor for the protocol using _setReserveFactorFresh
* @dev Admin function to accrue interest and set a new reserve factor
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _setReserveFactor(uint256 newReserveFactorMantissa)
external
override
nonReentrant
returns (uint256)
{
accrueInterest();
// _setReserveFactorFresh emits reserve-factor-specific logs on errors, so we don't need to.
return _setReserveFactorFresh(newReserveFactorMantissa);
}
/**
* @notice Sets a new reserve factor for the protocol (*requires fresh interest accrual)
* @dev Admin function to set a new reserve factor
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _setReserveFactorFresh(uint256 newReserveFactorMantissa)
internal
returns (uint256)
{
// Check caller is admin
if (msg.sender != admin) {
revert SetReserveFactorAdminCheck();
}
// Verify market's block number equals current block number
if (accrualBlockNumber != getBlockNumber()) {
revert SetReserveFactorFreshCheck();
}
// Check newReserveFactor 锟斤拷 maxReserveFactor
if (newReserveFactorMantissa > reserveFactorMaxMantissa) {
revert SetReserveFactorBoundsCheck();
}
uint256 oldReserveFactorMantissa = reserveFactorMantissa;
reserveFactorMantissa = newReserveFactorMantissa;
emit NewReserveFactor(
oldReserveFactorMantissa,
newReserveFactorMantissa
);
return NO_ERROR;
}
/**
* @notice Accrues interest and reduces reserves by transferring from msg.sender
* @param addAmount Amount of addition to reserves
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _addReservesInternal(uint256 addAmount)
internal
nonReentrant
returns (uint256)
{
accrueInterest();
// _addReservesFresh emits reserve-addition-specific logs on errors, so we don't need to.
_addReservesFresh(addAmount);
return NO_ERROR;
}
/**
* @notice Add reserves by transferring from caller
* @dev Requires fresh interest accrual
* @param addAmount Amount of addition to reserves
* @return (uint, uint) An error code (0=success, otherwise a failure (see ErrorReporter.sol for details)) and the actual amount added, net token fees
*/
function _addReservesFresh(uint256 addAmount)
internal
returns (uint256, uint256)
{
// totalReserves + actualAddAmount
uint256 totalReservesNew;
uint256 actualAddAmount;
// We fail gracefully unless market's block number equals current block number
if (accrualBlockNumber != getBlockNumber()) {
revert AddReservesFactorFreshCheck(actualAddAmount);
}
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
/*
* We call doTransferIn for the caller and the addAmount
* Note: The cToken must handle variations between ERC-20 and ETH underlying.
* On success, the cToken holds an additional addAmount of cash.
* doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred.
* it returns the amount actually transferred, in case of a fee.
*/
actualAddAmount = doTransferIn(msg.sender, addAmount);
totalReservesNew = totalReserves + actualAddAmount;
// Store reserves[n+1] = reserves[n] + actualAddAmount
totalReserves = totalReservesNew;
/* Emit NewReserves(admin, actualAddAmount, reserves[n+1]) */
emit ReservesAdded(msg.sender, actualAddAmount, totalReservesNew);
/* Return (NO_ERROR, actualAddAmount) */
return (NO_ERROR, actualAddAmount);
}
/**
* @notice Accrues interest and reduces reserves by transferring to admin
* @param reduceAmount Amount of reduction to reserves
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _reduceReserves(uint256 reduceAmount)
external
override
nonReentrant
returns (uint256)
{
accrueInterest();
// _reduceReservesFresh emits reserve-reduction-specific logs on errors, so we don't need to.
return _reduceReservesFresh(reduceAmount);
}
/**
* @notice Reduces reserves by transferring to admin
* @dev Requires fresh interest accrual
* @param reduceAmount Amount of reduction to reserves
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _reduceReservesFresh(uint256 reduceAmount)
internal
returns (uint256)
{
// totalReserves - reduceAmount
uint256 totalReservesNew;
// Check caller is admin
if (msg.sender != admin) {
revert ReduceReservesAdminCheck();
}
// We fail gracefully unless market's block number equals current block number
if (accrualBlockNumber != getBlockNumber()) {
revert ReduceReservesFreshCheck();
}
// Fail gracefully if protocol has insufficient underlying cash
if (getCashPrior() < reduceAmount) {
revert ReduceReservesCashNotAvailable();
}
// Check reduceAmount 锟斤拷 reserves[n] (totalReserves)
if (reduceAmount > totalReserves) {
revert ReduceReservesCashValidation();
}
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
totalReservesNew = totalReserves - reduceAmount;
// Store reserves[n+1] = reserves[n] - reduceAmount
totalReserves = totalReservesNew;
// doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.
doTransferOut(admin, reduceAmount);
emit ReservesReduced(admin, reduceAmount, totalReservesNew);
return NO_ERROR;
}
/**
* @notice accrues interest and updates the interest rate model using _setInterestRateModelFresh
* @dev Admin function to accrue interest and update the interest rate model
* @param newInterestRateModel the new interest rate model to use
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _setInterestRateModel(InterestRateModel newInterestRateModel)
public
override
returns (uint256)
{
accrueInterest();
// _setInterestRateModelFresh emits interest-rate-model-update-specific logs on errors, so we don't need to.
return _setInterestRateModelFresh(newInterestRateModel);
}
/**
* @notice updates the interest rate model (*requires fresh interest accrual)
* @dev Admin function to update the interest rate model
* @param newInterestRateModel the new interest rate model to use
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _setInterestRateModelFresh(InterestRateModel newInterestRateModel)
internal
returns (uint256)
{
// Used to store old model for use in the event that is emitted on success
InterestRateModel oldInterestRateModel;
// Check caller is admin
if (msg.sender != admin) {
revert SetInterestRateModelOwnerCheck();
}
// We fail gracefully unless market's block number equals current block number
if (accrualBlockNumber != getBlockNumber()) {
revert SetInterestRateModelFreshCheck();
}
// Track the market's current interest rate model
oldInterestRateModel = interestRateModel;
// Ensure invoke newInterestRateModel.isInterestRateModel() returns true
require(
newInterestRateModel.isInterestRateModel(),
"marker method returned false"
);
// Set the interest rate model to newInterestRateModel
interestRateModel = newInterestRateModel;
// Emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel)
emit NewMarketInterestRateModel(
oldInterestRateModel,
newInterestRateModel
);
return NO_ERROR;
}
/*** Safe Token ***/
/**
* @notice Gets balance of this contract in terms of the underlying
* @dev This excludes the value of the current message, if any
* @return The quantity of underlying owned by this contract
*/
function getCashPrior() internal view virtual returns (uint256);
/**
* @dev Performs a transfer in, reverting upon failure. Returns the amount actually transferred to the protocol, in case of a fee.
* This may revert due to insufficient balance or insufficient allowance.
*/
function doTransferIn(address from, uint256 amount)
internal
virtual
returns (uint256);
/**
* @dev Performs a transfer out, ideally returning an explanatory error code upon failure rather than reverting.
* If caller has not called checked protocol's balance, may revert due to insufficient cash held in the contract.
* If caller has checked protocol's balance, and verified it is >= amount, this should not revert in normal conditions.
*/
function doTransferOut(address payable to, uint256 amount) internal virtual;
/*** Reentrancy Guard ***/
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
*/
modifier nonReentrant() {
require(_notEntered, "re-entered");
_notEntered = false;
_;
_notEntered = true; // get a gas-refund post-Istanbul
}
}
// File: contracts\CEther.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
/**
* @title Compound's CEther Contract
* @notice CToken which wraps Ether
* @author Compound
*/
contract CEther is CToken {
/**
* @notice Construct a new CEther money market
* @param comptroller_ The address of the Comptroller
* @param interestRateModel_ The address of the interest rate model
* @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18
* @param name_ ERC-20 name of this token
* @param symbol_ ERC-20 symbol of this token
* @param decimals_ ERC-20 decimal precision of this token
* @param admin_ Address of the administrator of this token
*/
constructor(
ComptrollerInterface comptroller_,
InterestRateModel interestRateModel_,
uint initialExchangeRateMantissa_,
string memory name_,
string memory symbol_,
uint8 decimals_,
address payable admin_
) {
// Creator of the contract is admin during initialization
admin = payable(msg.sender);
initialize(
comptroller_,
interestRateModel_,
initialExchangeRateMantissa_,
name_,
symbol_,
decimals_
);
// Set the proper admin now that initialization is done
admin = admin_;
}
/*** User Interface ***/
/**
* @notice Sender supplies assets into the market and receives cTokens in exchange
* @dev Reverts upon any failure
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function mint() external payable returns (uint) {
mintInternal(msg.value);
return NO_ERROR;
}
/**
* @notice Sender redeems cTokens in exchange for the underlying asset
* @dev Accrues interest whether or not the operation succeeds, unless reverted
* @param redeemTokens The number of cTokens to redeem into underlying
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function redeem(uint redeemTokens) external returns (uint) {
redeemInternal(redeemTokens);
return NO_ERROR;
}
/**
* @notice Sender redeems cTokens in exchange for a specified amount of underlying asset
* @dev Accrues interest whether or not the operation succeeds, unless reverted
* @param redeemAmount The amount of underlying to redeem
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function redeemUnderlying(uint redeemAmount) external returns (uint) {
redeemUnderlyingInternal(redeemAmount);
return NO_ERROR;
}
/**
* @notice Sender borrows assets from the protocol to their own address
* @param borrowAmount The amount of the underlying asset to borrow
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function borrow(uint borrowAmount) external returns (uint) {
borrowInternal(borrowAmount);
return NO_ERROR;
}
/**
* @notice Sender repays their own borrow
* @dev Reverts upon any failure
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function repayBorrow() external payable returns (uint) {
repayBorrowInternal(msg.value);
return NO_ERROR;
}
/**
* @notice Sender repays a borrow belonging to borrower
* @dev Reverts upon any failure
* @param borrower the account with the debt being payed off
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function repayBorrowBehalf(
address borrower
) external payable returns (uint) {
repayBorrowBehalfInternal(borrower, msg.value);
return NO_ERROR;
}
/**
* @notice The sender liquidates the borrowers collateral.
* The collateral seized is transferred to the liquidator.
* @dev Reverts upon any failure
* @param borrower The borrower of this cToken to be liquidated
* @param cTokenCollateral The market in which to seize collateral from the borrower
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function liquidateBorrow(
address borrower,
CToken cTokenCollateral
) external payable returns (uint) {
liquidateBorrowInternal(borrower, msg.value, cTokenCollateral);
return NO_ERROR;
}
/**
* @notice The sender adds to reserves.
* @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)
*/
function _addReserves() external payable returns (uint) {
return _addReservesInternal(msg.value);
}
/**
* @notice Send Ether to CEther to mint
*/
receive() external payable {
mintInternal(msg.value);
}
/*** Safe Token ***/
/**
* @notice Gets balance of this contract in terms of Ether, before this message
* @dev This excludes the value of the current message, if any
* @return The quantity of Ether owned by this contract
*/
function getCashPrior() internal view override returns (uint) {
return address(this).balance - msg.value;
}
/**
* @notice Perform the actual transfer in, which is a no-op
* @param from Address sending the Ether
* @param amount Amount of Ether being sent
* @return The actual amount of Ether transferred
*/
function doTransferIn(
address from,
uint amount
) internal override returns (uint) {
// Sanity checks
require(msg.sender == from, "sender mismatch");
require(msg.value == amount, "value mismatch");
return amount;
}
function doTransferOut(
address payable to,
uint amount
) internal virtual override {
(bool sent, ) = to.call{value: amount}("");
require(sent, "failed to send ether");
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"internalType":"contract ComptrollerInterface","name":"comptroller_","type":"address"},{"internalType":"contract InterestRateModel","name":"interestRateModel_","type":"address"},{"internalType":"uint256","name":"initialExchangeRateMantissa_","type":"uint256"},{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"},{"internalType":"address payable","name":"admin_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AcceptAdminPendingAdminCheck","type":"error"},{"inputs":[{"internalType":"uint256","name":"actualAddAmount","type":"uint256"}],"name":"AddReservesFactorFreshCheck","type":"error"},{"inputs":[],"name":"BorrowCashNotAvailable","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"BorrowComptrollerRejection","type":"error"},{"inputs":[],"name":"BorrowFreshnessCheck","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"LiquidateAccrueBorrowInterestFailed","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"LiquidateAccrueCollateralInterestFailed","type":"error"},{"inputs":[],"name":"LiquidateCloseAmountIsUintMax","type":"error"},{"inputs":[],"name":"LiquidateCloseAmountIsZero","type":"error"},{"inputs":[],"name":"LiquidateCollateralFreshnessCheck","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"LiquidateComptrollerRejection","type":"error"},{"inputs":[],"name":"LiquidateFreshnessCheck","type":"error"},{"inputs":[],"name":"LiquidateLiquidatorIsBorrower","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"LiquidateRepayBorrowFreshFailed","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"LiquidateSeizeComptrollerRejection","type":"error"},{"inputs":[],"name":"LiquidateSeizeLiquidatorIsBorrower","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"MintComptrollerRejection","type":"error"},{"inputs":[],"name":"MintFreshnessCheck","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"RedeemComptrollerRejection","type":"error"},{"inputs":[],"name":"RedeemFreshnessCheck","type":"error"},{"inputs":[],"name":"RedeemTransferOutNotPossible","type":"error"},{"inputs":[],"name":"ReduceReservesAdminCheck","type":"error"},{"inputs":[],"name":"ReduceReservesCashNotAvailable","type":"error"},{"inputs":[],"name":"ReduceReservesCashValidation","type":"error"},{"inputs":[],"name":"ReduceReservesFreshCheck","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"RepayBorrowComptrollerRejection","type":"error"},{"inputs":[],"name":"RepayBorrowFreshnessCheck","type":"error"},{"inputs":[],"name":"SetComptrollerOwnerCheck","type":"error"},{"inputs":[],"name":"SetInterestRateModelFreshCheck","type":"error"},{"inputs":[],"name":"SetInterestRateModelOwnerCheck","type":"error"},{"inputs":[],"name":"SetPendingAdminOwnerCheck","type":"error"},{"inputs":[],"name":"SetReserveFactorAdminCheck","type":"error"},{"inputs":[],"name":"SetReserveFactorBoundsCheck","type":"error"},{"inputs":[],"name":"SetReserveFactorFreshCheck","type":"error"},{"inputs":[{"internalType":"uint256","name":"errorCode","type":"uint256"}],"name":"TransferComptrollerRejection","type":"error"},{"inputs":[],"name":"TransferNotAllowed","type":"error"},{"inputs":[],"name":"TransferNotEnough","type":"error"},{"inputs":[],"name":"TransferTooMuch","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cashPrior","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"interestAccumulated","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"borrowIndex","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalBorrows","type":"uint256"}],"name":"AccrueInterest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"uint256","name":"borrowAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accountBorrows","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalBorrows","type":"uint256"}],"name":"Borrow","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"liquidator","type":"address"},{"indexed":false,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"uint256","name":"repayAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"cTokenCollateral","type":"address"},{"indexed":false,"internalType":"uint256","name":"seizeTokens","type":"uint256"}],"name":"LiquidateBorrow","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"mintAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"mintTokens","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"NewAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract ComptrollerInterface","name":"oldComptroller","type":"address"},{"indexed":false,"internalType":"contract ComptrollerInterface","name":"newComptroller","type":"address"}],"name":"NewComptroller","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract InterestRateModel","name":"oldInterestRateModel","type":"address"},{"indexed":false,"internalType":"contract InterestRateModel","name":"newInterestRateModel","type":"address"}],"name":"NewMarketInterestRateModel","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldPendingAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newPendingAdmin","type":"address"}],"name":"NewPendingAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldReserveFactorMantissa","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newReserveFactorMantissa","type":"uint256"}],"name":"NewReserveFactor","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"redeemer","type":"address"},{"indexed":false,"internalType":"uint256","name":"redeemAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"redeemTokens","type":"uint256"}],"name":"Redeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"payer","type":"address"},{"indexed":false,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"uint256","name":"repayAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accountBorrows","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalBorrows","type":"uint256"}],"name":"RepayBorrow","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"benefactor","type":"address"},{"indexed":false,"internalType":"uint256","name":"addAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTotalReserves","type":"uint256"}],"name":"ReservesAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"admin","type":"address"},{"indexed":false,"internalType":"uint256","name":"reduceAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTotalReserves","type":"uint256"}],"name":"ReservesReduced","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":"Transfer","type":"event"},{"inputs":[],"name":"NO_ERROR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_acceptAdmin","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"_addReserves","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"reduceAmount","type":"uint256"}],"name":"_reduceReserves","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ComptrollerInterface","name":"newComptroller","type":"address"}],"name":"_setComptroller","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract InterestRateModel","name":"newInterestRateModel","type":"address"}],"name":"_setInterestRateModel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"newPendingAdmin","type":"address"}],"name":"_setPendingAdmin","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newReserveFactorMantissa","type":"uint256"}],"name":"_setReserveFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"accrualBlockNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accrueInterest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOfUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"borrowAmount","type":"uint256"}],"name":"borrow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"borrowBalanceCurrent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"borrowBalanceStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"borrowIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"borrowRatePerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"comptroller","outputs":[{"internalType":"contract ComptrollerInterface","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exchangeRateCurrent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"exchangeRateStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAccountSnapshot","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCash","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ComptrollerInterface","name":"comptroller_","type":"address"},{"internalType":"contract InterestRateModel","name":"interestRateModel_","type":"address"},{"internalType":"uint256","name":"initialExchangeRateMantissa_","type":"uint256"},{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"interestRateModel","outputs":[{"internalType":"contract InterestRateModel","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isCToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"borrower","type":"address"},{"internalType":"contract CToken","name":"cTokenCollateral","type":"address"}],"name":"liquidateBorrow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingAdmin","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"protocolSeizeShareMantissa","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"redeemTokens","type":"uint256"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"redeemAmount","type":"uint256"}],"name":"redeemUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"repayBorrow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"borrower","type":"address"}],"name":"repayBorrowBehalf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"reserveFactorMantissa","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"seizeTokens","type":"uint256"}],"name":"seize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"supplyRatePerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBorrows","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBorrowsCurrent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalReserves","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]Contract Creation Code
60806040523480156200001157600080fd5b5060405162003d9538038062003d95833981016040819052620000349162000773565b60038054610100600160a81b03191633610100021790556200005b8787878787876200008e565b600380546001600160a01b0390921661010002610100600160a81b031990921691909117905550620008a6945050505050565b60035461010090046001600160a01b03163314620000ff5760405162461bcd60e51b8152602060048201526024808201527f6f6e6c792061646d696e206d617920696e697469616c697a6520746865206d616044820152631c9ad95d60e21b60648201526084015b60405180910390fd5b600954158015620001105750600a54155b6200016a5760405162461bcd60e51b815260206004820152602360248201527f6d61726b6574206d6179206f6e6c7920626520696e697469616c697a6564206f6044820152626e636560e81b6064820152608401620000f6565b600784905583620001d75760405162461bcd60e51b815260206004820152603060248201527f696e697469616c2065786368616e67652072617465206d75737420626520677260448201526f32b0ba32b9103a3430b7103d32b9379760811b6064820152608401620000f6565b6000620001e48762000300565b90508015620002365760405162461bcd60e51b815260206004820152601a60248201527f73657474696e6720636f6d7074726f6c6c6572206661696c65640000000000006044820152606401620000f6565b42600955670de0b6b3a7640000600a55620002518662000458565b90508015620002ae5760405162461bcd60e51b815260206004820152602260248201527f73657474696e6720696e7465726573742072617465206d6f64656c206661696c604482015261195960f21b6064820152608401620000f6565b8351620002c3906001906020870190620005d5565b508251620002d9906002906020860190620005d5565b50506003805460ff90921660ff199283161790556000805490911660011790555050505050565b60035460009061010090046001600160a01b03163314620003345760405163d219dc1f60e01b815260040160405180910390fd5b60055460408051623f1ee960e11b815290516001600160a01b0392831692851691627e3dd29160048083019260209291908290030181865afa1580156200037f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620003a591906200083e565b620003f35760405162461bcd60e51b815260206004820152601c60248201527f6d61726b6572206d6574686f642072657475726e65642066616c7365000000006044820152606401620000f6565b600580546001600160a01b0319166001600160a01b0385811691821790925560408051928416835260208301919091527f7ac369dbd14fa5ea3f473ed67cc9d598964a77501540ba6751eb0b3decf5870d91015b60405180910390a150600092915050565b600354600090819061010090046001600160a01b031633146200048e5760405163407fded560e01b815260040160405180910390fd5b4260095414620004b157604051630be2a5cb60e11b815260040160405180910390fd5b600660009054906101000a90046001600160a01b03169050826001600160a01b0316632191f92a6040518163ffffffff1660e01b8152600401602060405180830381865afa15801562000508573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200052e91906200083e565b6200057c5760405162461bcd60e51b815260206004820152601c60248201527f6d61726b6572206d6574686f642072657475726e65642066616c7365000000006044820152606401620000f6565b600680546001600160a01b0319166001600160a01b0385811691821790925560408051928416835260208301919091527fedffc32e068c7c95dfd4bdfd5c4d939a084d6b11c4199eac8436ed234d72f926910162000447565b828054620005e39062000869565b90600052602060002090601f01602090048101928262000607576000855562000652565b82601f106200062257805160ff191683800117855562000652565b8280016001018555821562000652579182015b828111156200065257825182559160200191906001019062000635565b506200066092915062000664565b5090565b5b8082111562000660576000815560010162000665565b6001600160a01b03811681146200069157600080fd5b50565b634e487b7160e01b600052604160045260246000fd5b600082601f830112620006bc57600080fd5b81516001600160401b0380821115620006d957620006d962000694565b604051601f8301601f19908116603f0116810190828211818310171562000704576200070462000694565b816040528381526020925086838588010111156200072157600080fd5b600091505b8382101562000745578582018301518183018401529082019062000726565b83821115620007575760008385830101525b9695505050505050565b80516200076e816200067b565b919050565b600080600080600080600060e0888a0312156200078f57600080fd5b87516200079c816200067b565b6020890151909750620007af816200067b565b604089015160608a015191975095506001600160401b0380821115620007d457600080fd5b620007e28b838c01620006aa565b955060808a0151915080821115620007f957600080fd5b50620008088a828b01620006aa565b93505060a088015160ff811681146200082057600080fd5b91506200083060c0890162000761565b905092959891949750929550565b6000602082840312156200085157600080fd5b815180151581146200086257600080fd5b9392505050565b600181811c908216806200087e57607f821691505b60208210811415620008a057634e487b7160e01b600052602260045260246000fd5b50919050565b6134df80620008b66000396000f3fe6080604052600436106102975760003560e01c806395d89b411161015a578063c5ebeaec116100c1578063f3fdb15a1161007a578063f3fdb15a146107a7578063f851a440146107c7578063f8f9da28146107ec578063fca7820b14610801578063fcb6414714610821578063fe9c44ae1461082957600080fd5b8063c5ebeaec146106d9578063db006a75146106f9578063dd62ed3e14610719578063e59746191461075f578063e9c714f214610772578063f2b3abbd1461078757600080fd5b8063aae40a2a11610113578063aae40a2a1461061c578063ae9d70b01461062f578063b2a02ff114610644578063b71d1a0c14610664578063bd6d894d14610684578063c37f68e21461069957600080fd5b806395d89b411461057c57806395dd91931461059157806399d8c1b4146105b1578063a6afed95146105d1578063a9059cbb146105e6578063aa5af0fd1461060657600080fd5b80634576b5db116101fe57806369ab3250116101b757806369ab3250146104d05780636c540baf146104e557806370a08231146104fb57806373acee9814610531578063852a12e3146105465780638f840ddd1461056657600080fd5b80634576b5db1461043757806347bd3718146104575780634e4d9fea1461046d5780635fe3b56714610475578063601a0bf1146104955780636752e702146104b557600080fd5b8063182df0f511610250578063182df0f51461036957806323b872dd1461037e578063267822471461039e578063313ce567146103d65780633af9e669146104025780633b1d21a21461042257600080fd5b806306fdde03146102ac578063095ea7b3146102d75780631249c58b14610307578063173b99041461031d57806317bfdfbc1461033357806318160ddd1461035357600080fd5b366102a7576102a53461083e565b005b600080fd5b3480156102b857600080fd5b506102c1610896565b6040516102ce919061306e565b60405180910390f35b3480156102e357600080fd5b506102f76102f23660046130db565b610924565b60405190151581526020016102ce565b61030f610992565b6040519081526020016102ce565b34801561032957600080fd5b5061030f60085481565b34801561033f57600080fd5b5061030f61034e366004613107565b6109a3565b34801561035f57600080fd5b5061030f600d5481565b34801561037557600080fd5b5061030f6109f6565b34801561038a57600080fd5b506102f7610399366004613124565b610a05565b3480156103aa57600080fd5b506004546103be906001600160a01b031681565b6040516001600160a01b0390911681526020016102ce565b3480156103e257600080fd5b506003546103f09060ff1681565b60405160ff90911681526020016102ce565b34801561040e57600080fd5b5061030f61041d366004613107565b610a55565b34801561042e57600080fd5b5061030f610a9b565b34801561044357600080fd5b5061030f610452366004613107565b610aa5565b34801561046357600080fd5b5061030f600b5481565b61030f610bf7565b34801561048157600080fd5b506005546103be906001600160a01b031681565b3480156104a157600080fd5b5061030f6104b0366004613165565b610c02565b3480156104c157600080fd5b5061030f666379da05b6000081565b3480156104dc57600080fd5b5061030f600081565b3480156104f157600080fd5b5061030f60095481565b34801561050757600080fd5b5061030f610516366004613107565b6001600160a01b03166000908152600e602052604090205490565b34801561053d57600080fd5b5061030f610c41565b34801561055257600080fd5b5061030f610561366004613165565b610c8b565b34801561057257600080fd5b5061030f600c5481565b34801561058857600080fd5b506102c1610c9e565b34801561059d57600080fd5b5061030f6105ac366004613107565b610cab565b3480156105bd57600080fd5b506102a56105cc366004613221565b610cbc565b3480156105dd57600080fd5b5061030f610f17565b3480156105f257600080fd5b506102f76106013660046130db565b611105565b34801561061257600080fd5b5061030f600a5481565b61030f61062a3660046132cd565b611154565b34801561063b57600080fd5b5061030f61116a565b34801561065057600080fd5b5061030f61065f366004613124565b611202565b34801561067057600080fd5b5061030f61067f366004613107565b611251565b34801561069057600080fd5b5061030f6112de565b3480156106a557600080fd5b506106b96106b4366004613107565b61132e565b6040805194855260208501939093529183015260608201526080016102ce565b3480156106e557600080fd5b5061030f6106f4366004613165565b61136f565b34801561070557600080fd5b5061030f610714366004613165565b61137a565b34801561072557600080fd5b5061030f6107343660046132cd565b6001600160a01b039182166000908152600f6020908152604080832093909416825291909152205490565b61030f61076d366004613107565b611385565b34801561077e57600080fd5b5061030f611391565b34801561079357600080fd5b5061030f6107a2366004613107565b611498565b3480156107b357600080fd5b506006546103be906001600160a01b031681565b3480156107d357600080fd5b506003546103be9061010090046001600160a01b031681565b3480156107f857600080fd5b5061030f6114ac565b34801561080d57600080fd5b5061030f61081c366004613165565b6114ff565b61030f61153e565b34801561083557600080fd5b506102f7600181565b60005460ff166108695760405162461bcd60e51b815260040161086090613306565b60405180910390fd5b6000805460ff1916905561087b610f17565b506108863382611549565b506000805460ff19166001179055565b600180546108a39061332a565b80601f01602080910402602001604051908101604052809291908181526020018280546108cf9061332a565b801561091c5780601f106108f15761010080835404028352916020019161091c565b820191906000526020600020905b8154815290600101906020018083116108ff57829003601f168201915b505050505081565b336000818152600f602090815260408083206001600160a01b03871680855292528083208590555191929182907f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925906109809087815260200190565b60405180910390a35060019392505050565b600061099d3461083e565b50600090565b6000805460ff166109c65760405162461bcd60e51b815260040161086090613306565b6000805460ff191690556109d8610f17565b506109e282610cab565b90506000805460ff19166001179055919050565b6000610a006116ff565b905090565b6000805460ff16610a285760405162461bcd60e51b815260040161086090613306565b6000805460ff19168155610a3e33868686611769565b1490506000805460ff191660011790559392505050565b6000806040518060200160405280610a6b6112de565b90526001600160a01b0384166000908152600e6020526040902054909150610a94908290611997565b9392505050565b6000610a006119b7565b60035460009061010090046001600160a01b03163314610ad85760405163d219dc1f60e01b815260040160405180910390fd5b60055460408051623f1ee960e11b815290516001600160a01b0392831692851691627e3dd29160048083019260209291908290030181865afa158015610b22573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b46919061335f565b610b925760405162461bcd60e51b815260206004820152601c60248201527f6d61726b6572206d6574686f642072657475726e65642066616c7365000000006044820152606401610860565b600580546001600160a01b0319166001600160a01b0385811691821790925560408051928416835260208301919091527f7ac369dbd14fa5ea3f473ed67cc9d598964a77501540ba6751eb0b3decf5870d91015b60405180910390a150600092915050565b600061099d346119c3565b6000805460ff16610c255760405162461bcd60e51b815260040161086090613306565b6000805460ff19169055610c37610f17565b506109e282611a14565b6000805460ff16610c645760405162461bcd60e51b815260040161086090613306565b6000805460ff19169055610c76610f17565b5050600b546000805460ff1916600117905590565b6000610c9682611b2f565b506000919050565b600280546108a39061332a565b6000610cb682611b70565b92915050565b60035461010090046001600160a01b03163314610d275760405162461bcd60e51b8152602060048201526024808201527f6f6e6c792061646d696e206d617920696e697469616c697a6520746865206d616044820152631c9ad95d60e21b6064820152608401610860565b600954158015610d375750600a54155b610d8f5760405162461bcd60e51b815260206004820152602360248201527f6d61726b6574206d6179206f6e6c7920626520696e697469616c697a6564206f6044820152626e636560e81b6064820152608401610860565b600784905583610dfa5760405162461bcd60e51b815260206004820152603060248201527f696e697469616c2065786368616e67652072617465206d75737420626520677260448201526f32b0ba32b9103a3430b7103d32b9379760811b6064820152608401610860565b6000610e0587610aa5565b90508015610e555760405162461bcd60e51b815260206004820152601a60248201527f73657474696e6720636f6d7074726f6c6c6572206661696c65640000000000006044820152606401610860565b42600955670de0b6b3a7640000600a55610e6e86611bba565b90508015610ec95760405162461bcd60e51b815260206004820152602260248201527f73657474696e6720696e7465726573742072617465206d6f64656c206661696c604482015261195960f21b6064820152608401610860565b8351610edc906001906020870190612fde565b508251610ef0906002906020860190612fde565b50506003805460ff90921660ff199283161790556000805490911660011790555050505050565b600954600090429080821415610f305760009250505090565b6000610f3a6119b7565b600b54600c54600a546006546040516315f2405360e01b81526004810186905260248101859052604481018490529495509293919290916000916001600160a01b0316906315f2405390606401602060405180830381865afa158015610fa4573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610fc89190613381565b905065048c273950008111156110205760405162461bcd60e51b815260206004820152601c60248201527f626f72726f772072617465206973206162737572646c792068696768000000006044820152606401610860565b600061102c87896133b0565b9050600061104860405180602001604052808581525083611d2f565b905060006110568288611997565b9050600061106488836133c7565b905060006110836040518060200160405280600854815250848a611d60565b9050600061109285898a611d60565b60098e9055600a819055600b849055600c839055604080518d815260208101879052908101829052606081018590529091507f4dec04e750ca11537cabcd8a9eab06494de08da3735bc8871cd41250e190bc049060800160405180910390a160009d505050505050505050505050505090565b6000805460ff166111285760405162461bcd60e51b815260040161086090613306565b6000805460ff1916815561113e33808686611769565b1490506000805460ff1916600117905592915050565b6000611161833484611d81565b50600092915050565b6006546000906001600160a01b031663b81688166111866119b7565b600b54600c546008546040516001600160e01b031960e087901b16815260048101949094526024840192909252604483015260648201526084015b602060405180830381865afa1580156111de573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a009190613381565b6000805460ff166112255760405162461bcd60e51b815260040161086090613306565b6000805460ff1916905561123b33858585611e5f565b50600080805460ff191660011790559392505050565b60035460009061010090046001600160a01b0316331461128457604051635cb56c2b60e01b815260040160405180910390fd5b600480546001600160a01b038481166001600160a01b031983168117909355604080519190921680825260208201939093527fca4f2f25d0898edd99413412fb94012f9e54ec8142f9b093e7720646a95b16a99101610be6565b6000805460ff166113015760405162461bcd60e51b815260040161086090613306565b6000805460ff19169055611313610f17565b5061131c6109f6565b90506000805460ff1916600117905590565b6001600160a01b0381166000908152600e6020526040812054819081908190819061135887611b70565b6113606116ff565b93509350935093509193509193565b6000610c96826120d8565b6000610c9682612117565b6000610c968234612158565b6004546000906001600160a01b0316331415806113ac575033155b156113ca57604051631ba24f2960e21b815260040160405180910390fd5b60038054600480546001600160a01b03808216610100818102610100600160a81b0319871617968790556001600160a01b031990931690935560408051948390048216808652929095041660208401529290917ff9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc910160405180910390a1600454604080516001600160a01b03808516825290921660208301527fca4f2f25d0898edd99413412fb94012f9e54ec8142f9b093e7720646a95b16a9910160405180910390a160009250505090565b60006114a2610f17565b50610cb682611bba565b6006546000906001600160a01b03166315f240536114c86119b7565b600b54600c546040516001600160e01b031960e086901b1681526004810193909352602483019190915260448201526064016111c1565b6000805460ff166115225760405162461bcd60e51b815260040161086090613306565b6000805460ff19169055611534610f17565b506109e2826121aa565b6000610a0034612266565b600554604051634ef4c3e160e01b81526000916001600160a01b031690634ef4c3e19061157e903090879087906004016133df565b6020604051808303816000875af115801561159d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906115c19190613381565b905080156115e5576040516349abd4fd60e01b815260048101829052602401610860565b4260095414611607576040516338d8859760e01b815260040160405180910390fd5b6000604051806020016040528061161c6116ff565b90529050600061162c85856122bd565b9050600061163a828461234f565b905080600d5461164a91906133c7565b600d556001600160a01b0386166000908152600e60205260409020546116719082906133c7565b6001600160a01b0387166000908152600e60205260409081902091909155517f4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f906116c190889085908590613403565b60405180910390a16040518181526001600160a01b03871690309060008051602061348a8339815191529060200160405180910390a3505050505050565b600d546000908061171257505060075490565b600061171c6119b7565b90506000600c54600b548361173191906133c7565b61173b91906133b0565b9050600083611752670de0b6b3a764000084613424565b61175c9190613443565b95945050505050565b5090565b6005546040516317b9b84b60e31b81523060048201526001600160a01b038581166024830152848116604483015260648201849052600092839291169063bdcdc258906084016020604051808303816000875af11580156117ce573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117f29190613381565b905080156118165760405163089d427760e11b815260048101829052602401610860565b836001600160a01b0316856001600160a01b0316141561184957604051638cd22d1960e01b815260040160405180910390fd5b6000856001600160a01b0316876001600160a01b0316141561186e5750600019611896565b506001600160a01b038086166000908152600f60209081526040808320938a16835292905220545b60006118a285836133b0565b6001600160a01b0388166000908152600e6020526040812054919250906118ca9087906133b0565b6001600160a01b0388166000908152600e6020526040812054919250906118f29088906133c7565b6001600160a01b03808b166000908152600e6020526040808220869055918b168152208190559050600019841461194c576001600160a01b03808a166000908152600f60209081526040808320938e168352929052208390555b876001600160a01b0316896001600160a01b031660008051602061348a8339815191528960405161197f91815260200190565b60405180910390a35060009998505050505050505050565b6000806119a48484611d2f565b90506119af8161236d565b949350505050565b6000610a0034476133b0565b60005460ff166119e55760405162461bcd60e51b815260040161086090613306565b6000805460ff191690556119f7610f17565b50611a03333383612385565b50506000805460ff19166001179055565b600354600090819061010090046001600160a01b03163314611a4957604051630f7e5e6d60e41b815260040160405180910390fd5b4260095414611a6b57604051630dff50cb60e41b815260040160405180910390fd5b82611a746119b7565b1015611a9357604051633345e99960e01b815260040160405180910390fd5b600c54831115611ab6576040516378d2980560e11b815260040160405180910390fd5b82600c54611ac491906133b0565b600c819055600354909150611ae79061010090046001600160a01b03168461252e565b7f3bad0c59cf2f06e7314077049f48a93578cd16f5ef92329f1dab1420a99c177e600360019054906101000a90046001600160a01b03168483604051610be693929190613403565b60005460ff16611b515760405162461bcd60e51b815260040161086090613306565b6000805460ff19169055611b63610f17565b50610886336000836125cd565b6001600160a01b03811660009081526010602052604081208054611b975750600092915050565b600a548154600091611ba891613424565b90508160010154816119af9190613443565b600354600090819061010090046001600160a01b03163314611bef5760405163407fded560e01b815260040160405180910390fd5b4260095414611c1157604051630be2a5cb60e11b815260040160405180910390fd5b600660009054906101000a90046001600160a01b03169050826001600160a01b0316632191f92a6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611c67573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611c8b919061335f565b611cd75760405162461bcd60e51b815260206004820152601c60248201527f6d61726b6572206d6574686f642072657475726e65642066616c7365000000006044820152606401610860565b600680546001600160a01b0319166001600160a01b0385811691821790925560408051928416835260208301919091527fedffc32e068c7c95dfd4bdfd5c4d939a084d6b11c4199eac8436ed234d72f9269101610be6565b6040805160208101909152600081526040518060200160405280611d578560000151856128aa565b90529392505050565b600080611d6d8585611d2f565b905061175c611d7b8261236d565b846128b6565b60005460ff16611da35760405162461bcd60e51b815260040161086090613306565b6000805460ff19169055611db5610f17565b506000816001600160a01b031663a6afed956040518163ffffffff1660e01b81526004016020604051808303816000875af1158015611df8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611e1c9190613381565b90508015611e4057604051633eea49b760e11b815260048101829052602401610860565b611e4c338585856128c2565b50506000805460ff191660011790555050565b60055460405163d02f735160e01b81523060048201526001600160a01b0386811660248301528581166044830152848116606483015260848201849052600092169063d02f73519060a4016020604051808303816000875af1158015611ec9573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611eed9190613381565b90508015611f11576040516363e00e3360e11b815260048101829052602401610860565b836001600160a01b0316836001600160a01b03161415611f4457604051633a94626760e11b815260040160405180910390fd5b6000611f65836040518060200160405280666379da05b60000815250612d7c565b90506000611f7382856133b0565b905060006040518060200160405280611f8a6116ff565b905290506000611f9a8285611997565b9050600081600c54611fac91906133c7565b600c819055600d54909150611fc29086906133b0565b600d556001600160a01b0388166000908152600e6020526040902054611fe99088906133b0565b6001600160a01b03808a166000908152600e602052604080822093909355908b16815220546120199085906133c7565b6001600160a01b03808b166000818152600e602052604090819020939093559151908a169060008051602061348a8339815191529061205b9088815260200190565b60405180910390a360405185815230906001600160a01b038a169060008051602061348a8339815191529060200160405180910390a37fa91e67c5ea634cd43a12c5a482724b03de01e85ca68702a53d0c2f45cb7c1dc53083836040516120c493929190613403565b60405180910390a150505050505050505050565b60005460ff166120fa5760405162461bcd60e51b815260040161086090613306565b6000805460ff1916905561210c610f17565b506108863382612d9f565b60005460ff166121395760405162461bcd60e51b815260040161086090613306565b6000805460ff1916905561214b610f17565b50610886338260006125cd565b60005460ff1661217a5760405162461bcd60e51b815260040161086090613306565b6000805460ff1916905561218c610f17565b50612198338383612385565b50506000805460ff1916600117905550565b60035460009061010090046001600160a01b031633146121dd57604051631205b57b60e11b815260040160405180910390fd5b42600954146121ff57604051637dfca6b760e11b815260040160405180910390fd5b670de0b6b3a76400008211156122285760405163717220f360e11b815260040160405180910390fd5b600880549083905560408051828152602081018590527faaa68312e2ea9d50e16af5068410ab56e1a1fd06037b1a35664812c30f8214609101610be6565b6000805460ff166122895760405162461bcd60e51b815260040161086090613306565b6000805460ff1916905561229b610f17565b506122a582612f3e565b5050600090506000805460ff19166001179055919050565b6000336001600160a01b038416146123095760405162461bcd60e51b815260206004820152600f60248201526e0e6cadcc8cae440dad2e6dac2e8c6d608b1b6044820152606401610860565b8134146123495760405162461bcd60e51b815260206004820152600e60248201526d0ecc2d8eaca40dad2e6dac2e8c6d60931b6044820152606401610860565b50919050565b6000610a9461236684670de0b6b3a76400006128aa565b8351612fd2565b8051600090610cb690670de0b6b3a764000090613443565b600554604051631200453160e11b81523060048201526001600160a01b03858116602483015284811660448301526064820184905260009283929116906324008a62906084016020604051808303816000875af11580156123ea573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061240e9190613381565b9050801561243257604051638c81362d60e01b815260048101829052602401610860565b42600954146124545760405163c9021e2f60e01b815260040160405180910390fd5b600061245f85611b70565b9050600060001985146124725784612474565b815b9050600061248288836122bd565b9050600061249082856133b0565b9050600082600b546124a291906133b0565b6001600160a01b038a8116600081815260106020908152604091829020878155600a54600190910155600b8590558151938f168452830191909152810185905260608101849052608081018290529091507f1a2a22cb034d26d1854bdc6666a5b91fe25efbbb5dcad3b0355478d6f5c362a19060a00160405180910390a1509098975050505050505050565b6000826001600160a01b03168260405160006040518083038185875af1925050503d806000811461257b576040519150601f19603f3d011682016040523d82523d6000602084013e612580565b606091505b50509050806125c85760405162461bcd60e51b81526020600482015260146024820152733330b4b632b2103a379039b2b7321032ba3432b960611b6044820152606401610860565b505050565b8115806125d8575080155b6126415760405162461bcd60e51b815260206004820152603460248201527f6f6e65206f662072656465656d546f6b656e73496e206f722072656465656d416044820152736d6f756e74496e206d757374206265207a65726f60601b6064820152608401610860565b600060405180602001604052806126566116ff565b905290506000808415612677578491506126708386611997565b9050612687565b612681848461234f565b91508390505b60055460405163eabe7d9160e01b81526000916001600160a01b03169063eabe7d91906126bc9030908b9088906004016133df565b6020604051808303816000875af11580156126db573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906126ff9190613381565b905080156127235760405163480f424760e01b815260048101829052602401610860565b4260095414612745576040516397b5cfcd60e01b815260040160405180910390fd5b8161274e6119b7565b101561276d576040516391240a1b60e01b815260040160405180910390fd5b82600d5461277b91906133b0565b600d556001600160a01b0387166000908152600e60205260409020546127a29084906133b0565b6001600160a01b0388166000908152600e60205260409020556127c5878361252e565b60405183815230906001600160a01b0389169060008051602061348a8339815191529060200160405180910390a37fe5b754fb1abb7f01b499791d0b820ae3b6af3424ac1c59768edb53f4ec31a92987838560405161282693929190613403565b60405180910390a16005546040516351dff98960e01b81523060048201526001600160a01b0389811660248301526044820185905260648201869052909116906351dff98990608401600060405180830381600087803b15801561288957600080fd5b505af115801561289d573d6000803e3d6000fd5b5050505050505050505050565b6000610a948284613424565b6000610a9482846133c7565b600554604051632fe3f38f60e11b81523060048201526001600160a01b03838116602483015286811660448301528581166064830152608482018590526000921690635fc7e71e9060a4016020604051808303816000875af115801561292c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129509190613381565b9050801561297457604051630a14d17960e11b815260048101829052602401610860565b4260095414612996576040516380965b1b60e01b815260040160405180910390fd5b42826001600160a01b0316636c540baf6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156129d5573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129f99190613381565b14612a1757604051631046f38d60e31b815260040160405180910390fd5b846001600160a01b0316846001600160a01b03161415612a4a57604051631bd1a62160e21b815260040160405180910390fd5b82612a685760405163d29da7ef60e01b815260040160405180910390fd5b600019831415612a8b57604051635982c5bb60e11b815260040160405180910390fd5b6000612a98868686612385565b60055460405163c488847b60e01b815291925060009182916001600160a01b03169063c488847b90612ad2903090899088906004016133df565b6040805180830381865afa158015612aee573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612b129190613465565b9150915060008214612b825760405162461bcd60e51b815260206004820152603360248201527f4c49515549444154455f434f4d5054524f4c4c45525f43414c43554c4154455f604482015272105353d5539517d4d152569157d19052531151606a1b6064820152608401610860565b6040516370a0823160e01b81526001600160a01b0388811660048301528291908716906370a0823190602401602060405180830381865afa158015612bcb573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612bef9190613381565b1015612c3d5760405162461bcd60e51b815260206004820152601860248201527f4c49515549444154455f5345495a455f544f4f5f4d55434800000000000000006044820152606401610860565b6001600160a01b038516301415612c5f57612c5a30898984611e5f565b612d19565b60405163b2a02ff160e01b81526000906001600160a01b0387169063b2a02ff190612c92908c908c9087906004016133df565b6020604051808303816000875af1158015612cb1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612cd59190613381565b14612d195760405162461bcd60e51b81526020600482015260146024820152731d1bdad95b881cd95a5e9d5c994819985a5b195960621b6044820152606401610860565b604080516001600160a01b038a811682528981166020830152818301869052871660608201526080810183905290517f298637f684da70674f26509b10f07ec2fbc77a335ab1e7d6215a4b2484d8bb529181900360a00190a15050505050505050565b6000670de0b6b3a7640000612d958484600001516128aa565b610a949190613443565b60055460405163368f515360e21b81526000916001600160a01b03169063da3d454c90612dd4903090879087906004016133df565b6020604051808303816000875af1158015612df3573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612e179190613381565b90508015612e3b5760405163918db40f60e01b815260048101829052602401610860565b4260095414612e5d57604051630e8d8c6160e21b815260040160405180910390fd5b81612e666119b7565b1015612e85576040516348c2588160e01b815260040160405180910390fd5b6000612e9084611b70565b90506000612e9e84836133c7565b9050600084600b54612eb091906133c7565b6001600160a01b0387166000908152601060205260409020838155600a54600190910155600b8190559050612ee5868661252e565b604080516001600160a01b038816815260208101879052908101839052606081018290527f13ed6866d4e1ee6da46f845c46d7e54120883d75c5ea9a2dacc1c4ca8984ab809060800160405180910390a1505050505050565b60008080804260095414612f68576040516338acf79960e01b815260048101829052602401610860565b612f7233866122bd565b905080600c54612f8291906133c7565b915081600c819055507fa91e67c5ea634cd43a12c5a482724b03de01e85ca68702a53d0c2f45cb7c1dc5338284604051612fbe93929190613403565b60405180910390a160009590945092505050565b6000610a948284613443565b828054612fea9061332a565b90600052602060002090601f01602090048101928261300c5760008555613052565b82601f1061302557805160ff1916838001178555613052565b82800160010185558215613052579182015b82811115613052578251825591602001919060010190613037565b506117659291505b80821115611765576000815560010161305a565b600060208083528351808285015260005b8181101561309b5785810183015185820160400152820161307f565b818111156130ad576000604083870101525b50601f01601f1916929092016040019392505050565b6001600160a01b03811681146130d857600080fd5b50565b600080604083850312156130ee57600080fd5b82356130f9816130c3565b946020939093013593505050565b60006020828403121561311957600080fd5b8135610a94816130c3565b60008060006060848603121561313957600080fd5b8335613144816130c3565b92506020840135613154816130c3565b929592945050506040919091013590565b60006020828403121561317757600080fd5b5035919050565b634e487b7160e01b600052604160045260246000fd5b600082601f8301126131a557600080fd5b813567ffffffffffffffff808211156131c0576131c061317e565b604051601f8301601f19908116603f011681019082821181831017156131e8576131e861317e565b8160405283815286602085880101111561320157600080fd5b836020870160208301376000602085830101528094505050505092915050565b60008060008060008060c0878903121561323a57600080fd5b8635613245816130c3565b95506020870135613255816130c3565b945060408701359350606087013567ffffffffffffffff8082111561327957600080fd5b6132858a838b01613194565b9450608089013591508082111561329b57600080fd5b506132a889828a01613194565b92505060a087013560ff811681146132bf57600080fd5b809150509295509295509295565b600080604083850312156132e057600080fd5b82356132eb816130c3565b915060208301356132fb816130c3565b809150509250929050565b6020808252600a90820152691c994b595b9d195c995960b21b604082015260600190565b600181811c9082168061333e57607f821691505b6020821081141561234957634e487b7160e01b600052602260045260246000fd5b60006020828403121561337157600080fd5b81518015158114610a9457600080fd5b60006020828403121561339357600080fd5b5051919050565b634e487b7160e01b600052601160045260246000fd5b6000828210156133c2576133c261339a565b500390565b600082198211156133da576133da61339a565b500190565b6001600160a01b039384168152919092166020820152604081019190915260600190565b6001600160a01b039390931683526020830191909152604082015260600190565b600081600019048311821515161561343e5761343e61339a565b500290565b60008261346057634e487b7160e01b600052601260045260246000fd5b500490565b6000806040838503121561347857600080fd5b50508051602090910151909290915056feddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efa2646970667358221220c0bf655b27c753d5c126052cc8f872976ad1494ad1c3590111e53cb1d7c38efb64736f6c634300080a0033000000000000000000000000caabf6ffb76634183254b0a4a3d5fb36180fdae40000000000000000000000001b85b58ac1d75489d1eced61dc1c7008e1519258000000000000000000000000000000000000000000a56fa5b99019a5c800000000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000000800000000000000000000000026f6d954c4132fae4efe389b947c8cc4b4ce5ce7000000000000000000000000000000000000000000000000000000000000000b537769726c20457468657200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047345544800000000000000000000000000000000000000000000000000000000
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000caabf6ffb76634183254b0a4a3d5fb36180fdae40000000000000000000000001b85b58ac1d75489d1eced61dc1c7008e1519258000000000000000000000000000000000000000000a56fa5b99019a5c800000000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000000800000000000000000000000026f6d954c4132fae4efe389b947c8cc4b4ce5ce7000000000000000000000000000000000000000000000000000000000000000b537769726c20457468657200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047345544800000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : comptroller_ (address): 0xcAABf6Ffb76634183254B0a4a3D5fb36180FdAE4
Arg [1] : interestRateModel_ (address): 0x1b85b58ac1d75489D1ECEd61DC1c7008E1519258
Arg [2] : initialExchangeRateMantissa_ (uint256): 200000000000000000000000000
Arg [3] : name_ (string): Swirl Ether
Arg [4] : symbol_ (string): sETH
Arg [5] : decimals_ (uint8): 8
Arg [6] : admin_ (address): 0x26f6d954c4132fae4eFe389b947c8CC4B4CE5CE7
-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 000000000000000000000000caabf6ffb76634183254b0a4a3d5fb36180fdae4
Arg [1] : 0000000000000000000000001b85b58ac1d75489d1eced61dc1c7008e1519258
Arg [2] : 000000000000000000000000000000000000000000a56fa5b99019a5c8000000
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [6] : 00000000000000000000000026f6d954c4132fae4efe389b947c8cc4b4ce5ce7
Arg [7] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [8] : 537769726c204574686572000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [10] : 7345544800000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
84270:6018:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89121:23;89134:9;89121:12;:23::i;:::-;84270:6018;;;;;11759:18;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36485:278;;;;;;;;;;-1:-1:-1;36485:278:0;;;;;:::i;:::-;;:::i;:::-;;;1237:14:1;;1230:22;1212:41;;1200:2;1185:18;36485:278:0;1072:187:1;85773:116:0;;;:::i;:::-;;;1410:25:1;;;1398:2;1383:18;85773:116:0;1264:177:1;12982:33:0;;;;;;;;;;;;;;;;40659:218;;;;;;;;;;-1:-1:-1;40659:218:0;;;;;:::i;:::-;;:::i;13627:23::-;;;;;;;;;;;;;;;;42976:123;;;;;;;;;;;;;:::i;35780:226::-;;;;;;;;;;-1:-1:-1;35780:226:0;;;;;:::i;:::-;;:::i;12432:35::-;;;;;;;;;;-1:-1:-1;12432:35:0;;;;-1:-1:-1;;;;;12432:35:0;;;;;;-1:-1:-1;;;;;2339:32:1;;;2321:51;;2309:2;2294:18;12432:35:0;2159:219:1;11955:21:0;;;;;;;;;;-1:-1:-1;11955:21:0;;;;;;;;;;;2555:4:1;2543:17;;;2525:36;;2513:2;2498:18;11955:21:0;2383:184:1;37853:267:0;;;;;;;;;;-1:-1:-1;37853:267:0;;;;;:::i;:::-;;:::i;44408:100::-;;;;;;;;;;;;;:::i;72991:728::-;;;;;;;;;;-1:-1:-1;72991:728:0;;;;;:::i;:::-;;:::i;13391:24::-;;;;;;;;;;;;;;;;87475:130;;;:::i;12558:39::-;;;;;;;;;;-1:-1:-1;12558:39:0;;;;-1:-1:-1;;;;;12558:39:0;;;78213:327;;;;;;;;;;-1:-1:-1;78213:327:0;;;;;:::i;:::-;;:::i;14522:56::-;;;;;;;;;;;;14572:6;14522:56;;9618:33;;;;;;;;;;;;9650:1;9618:33;;13105:30;;;;;;;;;;;;;;;;37476:121;;;;;;;;;;-1:-1:-1;37476:121:0;;;;;:::i;:::-;-1:-1:-1;;;;;37569:20:0;37542:7;37569:20;;;:13;:20;;;;;;;37476:121;40182:186;;;;;;;;;;;;;:::i;86728:152::-;;;;;;;;;;-1:-1:-1;86728:152:0;;;;;:::i;:::-;;:::i;13521:25::-;;;;;;;;;;;;;;;;11855:20;;;;;;;;;;;;;:::i;41086:188::-;;;;;;;;;;-1:-1:-1;41086:188:0;;;;;:::i;:::-;;:::i;31273:1521::-;;;;;;;;;;-1:-1:-1;31273:1521:0;;;;;:::i;:::-;;:::i;44756:2933::-;;;;;;;;;;;;;:::i;35250:223::-;;;;;;;;;;-1:-1:-1;35250:223:0;;;;;:::i;:::-;;:::i;13256:23::-;;;;;;;;;;;;;;;;88508:232;;;;;;:::i;:::-;;:::i;39744:292::-;;;;;;;;;;;;;:::i;67630:264::-;;;;;;;;;;-1:-1:-1;67630:264:0;;;;;:::i;:::-;;:::i;71140:639::-;;;;;;;;;;-1:-1:-1;71140:639:0;;;;;:::i;:::-;;:::i;42534:192::-;;;;;;;;;;;;;:::i;38466:408::-;;;;;;;;;;-1:-1:-1;38466:408:0;;;;;:::i;:::-;;:::i;:::-;;;;6141:25:1;;;6197:2;6182:18;;6175:34;;;;6225:18;;;6218:34;6283:2;6268:18;;6261:34;6128:3;6113:19;38466:408:0;5910:391:1;87144:132:0;;;;;;;;;;-1:-1:-1;87144:132:0;;;;;:::i;:::-;;:::i;86240:::-;;;;;;;;;;-1:-1:-1;86240:132:0;;;;;:::i;:::-;;:::i;37093:193::-;;;;;;;;;;-1:-1:-1;37093:193:0;;;;;:::i;:::-;-1:-1:-1;;;;;37244:25:0;;;37212:7;37244:25;;;:18;:25;;;;;;;;:34;;;;;;;;;;;;;37093:193;87884:184;;;;;;:::i;:::-;;:::i;72053:717::-;;;;;;;;;;;;;:::i;80613:356::-;;;;;;;;;;-1:-1:-1;80613:356:0;;;;;:::i;:::-;;:::i;12699:42::-;;;;;;;;;;-1:-1:-1;12699:42:0;;;;-1:-1:-1;;;;;12699:42:0;;;12321:28;;;;;;;;;;-1:-1:-1;12321:28:0;;;;;;;-1:-1:-1;;;;;12321:28:0;;;39316:252;;;;;;;;;;;;;:::i;74018:354::-;;;;;;;;;;-1:-1:-1;74018:354:0;;;;;:::i;:::-;;:::i;88899:113::-;;;:::i;14743:36::-;;;;;;;;;;;;14775:4;14743:36;;47959:247;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;;;;;;;;;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;48034:16:::1;:14;:16::i;:::-;;48165:33;48175:10;48187;48165:9;:33::i;:::-;-1:-1:-1::0;84005:11:0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;47959:247::o;11759:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;36485:278::-;36625:10;36589:4;36646:23;;;:18;:23;;;;;;;;-1:-1:-1;;;;;36646:32:0;;;;;;;;;;:41;;;36703:30;36589:4;;36625:10;;;36703:30;;;;36681:6;1410:25:1;;1398:2;1383:18;;1264:177;36703:30:0;;;;;;;;-1:-1:-1;36751:4:0;;36485:278;-1:-1:-1;;;36485:278:0:o;85773:116::-;85815:4;85832:23;85845:9;85832:12;:23::i;:::-;-1:-1:-1;9650:1:0;;85773:116::o;40659:218::-;40782:7;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;40807:16:::1;:14;:16::i;:::-;;40841:28;40861:7;40841:19;:28::i;:::-;40834:35;;84005:11:::0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;40659:218;;-1:-1:-1;40659:218:0:o;42976:123::-;43036:7;43063:28;:26;:28::i;:::-;43056:35;;42976:123;:::o;35780:226::-;35918:4;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;35942:44:::1;35957:10;35969:3:::0;35974;35979:6;35942:14:::1;:44::i;:::-;:56;35935:63;;84005:11:::0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;35780:226;;-1:-1:-1;;;35780:226:0:o;37853:267::-;37951:7;37976:23;38002:38;;;;;;;;38017:21;:19;:21::i;:::-;38002:38;;-1:-1:-1;;;;;38091:20:0;;;;;;:13;:20;;;;;;37976:64;;-1:-1:-1;38058:54:0;;37976:64;;38058:18;:54::i;:::-;38051:61;37853:267;-1:-1:-1;;;37853:267:0:o;44408:100::-;44459:7;44486:14;:12;:14::i;72991:728::-;73182:5;;73105:7;;73182:5;;;-1:-1:-1;;;;;73182:5:0;73168:10;:19;73164:85;;73211:26;;-1:-1:-1;;;73211:26:0;;;;;;;;;;;73164:85;73299:11;;73396:30;;;-1:-1:-1;;;73396:30:0;;;;-1:-1:-1;;;;;73299:11:0;;;;73396:28;;;;;:30;;;;;;;;;;;;;;:28;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73388:71;;;;-1:-1:-1;;;73388:71:0;;8417:2:1;73388:71:0;;;8399:21:1;8456:2;8436:18;;;8429:30;8495;8475:18;;;8468:58;8543:18;;73388:71:0;8215:352:1;73388:71:0;73527:11;:28;;-1:-1:-1;;;;;;73527:28:0;-1:-1:-1;;;;;73527:28:0;;;;;;;;;73637:46;;;8858:15:1;;;8840:34;;8905:2;8890:18;;8883:43;;;;73637:46:0;;8775:18:1;73637:46:0;;;;;;;;-1:-1:-1;9650:1:0;;72991:728;-1:-1:-1;;72991:728:0:o;87475:130::-;87524:4;87541:30;87561:9;87541:19;:30::i;78213:327::-;78336:7;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;78361:16:::1;:14;:16::i;:::-;;78498:34;78519:12;78498:20;:34::i;40182:186::-:0;40289:7;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;40314:16:::1;:14;:16::i;:::-;-1:-1:-1::0;;40348:12:0::1;::::0;84005:11;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;40182:186;:::o;86728:152::-;86791:4;86808:38;86833:12;86808:24;:38::i;:::-;-1:-1:-1;9650:1:0;;86728:152;-1:-1:-1;86728:152:0:o;11855:20::-;;;;;;;:::i;41086:188::-;41198:7;41230:36;41258:7;41230:27;:36::i;:::-;41223:43;41086:188;-1:-1:-1;;41086:188:0:o;31273:1521::-;31566:5;;;;;-1:-1:-1;;;;;31566:5:0;31552:10;:19;31544:68;;;;-1:-1:-1;;;31544:68:0;;9139:2:1;31544:68:0;;;9121:21:1;9178:2;9158:18;;;9151:30;9217:34;9197:18;;;9190:62;-1:-1:-1;;;9268:18:1;;;9261:34;9312:19;;31544:68:0;8937:400:1;31544:68:0;31645:18;;:23;:43;;;;-1:-1:-1;31672:11:0;;:16;31645:43;31623:128;;;;-1:-1:-1;;;31623:128:0;;9544:2:1;31623:128:0;;;9526:21:1;9583:2;9563:18;;;9556:30;9622:34;9602:18;;;9595:62;-1:-1:-1;;;9673:18:1;;;9666:33;9716:19;;31623:128:0;9342:399:1;31623:128:0;31802:27;:58;;;31893:31;31871:129;;;;-1:-1:-1;;;31871:129:0;;9948:2:1;31871:129:0;;;9930:21:1;9987:2;9967:18;;;9960:30;10026:34;10006:18;;;9999:62;-1:-1:-1;;;10077:18:1;;;10070:46;10133:19;;31871:129:0;9746:412:1;31871:129:0;32045:11;32059:29;32075:12;32059:15;:29::i;:::-;32045:43;-1:-1:-1;32107:15:0;;32099:54;;;;-1:-1:-1;;;32099:54:0;;10365:2:1;32099:54:0;;;10347:21:1;10404:2;10384:18;;;10377:30;10443:28;10423:18;;;10416:56;10489:18;;32099:54:0;10163:350:1;32099:54:0;39117:15;32272:18;:37;25088:4;32320:11;:25;32445:46;32472:18;32445:26;:46::i;:::-;32439:52;-1:-1:-1;32510:15:0;;32502:62;;;;-1:-1:-1;;;32502:62:0;;10720:2:1;32502:62:0;;;10702:21:1;10759:2;10739:18;;;10732:30;10798:34;10778:18;;;10771:62;-1:-1:-1;;;10849:18:1;;;10842:32;10891:19;;32502:62:0;10518:398:1;32502:62:0;32577:12;;;;:4;;:12;;;;;:::i;:::-;-1:-1:-1;32600:16:0;;;;:6;;:16;;;;;:::i;:::-;-1:-1:-1;;32627:8:0;:20;;;;;;-1:-1:-1;;32627:20:0;;;;;;:8;32768:18;;;;;32627:20;32768:18;;;-1:-1:-1;;;;;31273:1521:0:o;44756:2933::-;44974:18;;44815:7;;39117:15;;45062:45;;;45058:93;;;9650:1;45124:15;;;;44756:2933;:::o;45058:93::-;45218:17;45238:14;:12;:14::i;:::-;45286:12;;45333:13;;45384:11;;45495:17;;:121;;-1:-1:-1;;;45495:121:0;;;;;11123:25:1;;;11164:18;;;11157:34;;;11207:18;;;11200:34;;;45218::0;;-1:-1:-1;45286:12:0;;45333:13;;45384:11;;45263:20;;-1:-1:-1;;;;;45495:17:0;;:31;;11096:18:1;;45495:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45466:150;;12102:9;45649:18;:43;;45627:121;;;;-1:-1:-1;;;45627:121:0;;11636:2:1;45627:121:0;;;11618:21:1;11675:2;11655:18;;;11648:30;11714;11694:18;;;11687:58;11762:18;;45627:121:0;11434:352:1;45627:121:0;45838:18;45859:44;45880:23;45859:18;:44;:::i;:::-;45838:65;;46395:31;46429:90;46448:35;;;;;;;;46463:18;46448:35;;;46498:10;46429:4;:90::i;:::-;46395:124;;46530:27;46560:91;46593:20;46628:12;46560:18;:91::i;:::-;46530:121;-1:-1:-1;46662:23:0;46688:34;46710:12;46530:121;46688:34;:::i;:::-;46662:60;;46733:24;46760:151;46800:38;;;;;;;;46815:21;;46800:38;;;46853:19;46887:13;46760:25;:151::i;:::-;46733:178;;46922:22;46947:133;46987:20;47022:16;47053;46947:25;:133::i;:::-;47284:18;:39;;;47334:11;:28;;;47373:12;:30;;;47414:13;:32;;;47511:142;;;6141:25:1;;;6197:2;6182:18;;6175:34;;;6225:18;;;6218:34;;;6283:2;6268:18;;6261:34;;;47334:28:0;;-1:-1:-1;47511:142:0;;6128:3:1;6113:19;47511:142:0;;;;;;;9650:1;47666:15;;;;;;;;;;;;;;;44756:2933;:::o;35250:223::-;35373:4;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;35402:51:::1;35417:10;::::0;35441:3;35446:6;35402:14:::1;:51::i;:::-;:63;35395:70;;84005:11:::0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;35250:223;;-1:-1:-1;;35250:223:0:o;88508:232::-;88627:4;88644:62;88668:8;88678:9;88689:16;88644:23;:62::i;:::-;-1:-1:-1;9650:1:0;88508:232;;;;:::o;39744:292::-;39846:17;;39806:7;;-1:-1:-1;;;;;39846:17:0;:31;39896:14;:12;:14::i;:::-;39929:12;;39960:13;;39992:21;;39846:182;;-1:-1:-1;;;;;;39846:182:0;;;;;;;;;;6141:25:1;;;;6182:18;;;6175:34;;;;6225:18;;;6218:34;6268:18;;;6261:34;6113:19;;39846:182:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;67630:264::-;67778:7;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;67798:60:::1;67812:10;67824::::0;67836:8;67846:11;67798:13:::1;:60::i;:::-;-1:-1:-1::0;9650:1:0::1;84005:11:::0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;67630:264;;-1:-1:-1;;;67630:264:0:o;71140:639::-;71329:5;;71253:7;;71329:5;;;-1:-1:-1;;;;;71329:5:0;71315:10;:19;71311:86;;71358:27;;-1:-1:-1;;;71358:27:0;;;;;;;;;;;71311:86;71496:12;;;-1:-1:-1;;;;;71579:30:0;;;-1:-1:-1;;;;;;71579:30:0;;;;;;;71694:49;;;71496:12;;;;8840:34:1;;;8905:2;8890:18;;8883:43;;;;71694:49:0;;8775:18:1;71694:49:0;8572:360:1;42534:192:0;42639:7;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;42664:16:::1;:14;:16::i;:::-;;42698:20;:18;:20::i;:::-;42691:27;;84005:11:::0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;42534:192;:::o;38466:408::-;-1:-1:-1;;;;;38739:22:0;;38593:7;38739:22;;;:13;:22;;;;;;38593:7;;;;;;;;38776:36;38753:7;38776:27;:36::i;:::-;38827:28;:26;:28::i;:::-;38694:172;;;;;;;;38466:408;;;;;:::o;87144:132::-;87197:4;87214:28;87229:12;87214:14;:28::i;86240:132::-;86293:4;86310:28;86325:12;86310:14;:28::i;87884:184::-;87971:4;87988:46;88014:8;88024:9;87988:25;:46::i;72053:717::-;72221:12;;72104:7;;-1:-1:-1;;;;;72221:12:0;72207:10;:26;;;:54;;-1:-1:-1;72237:10:0;:24;72207:54;72203:124;;;72285:30;;-1:-1:-1;;;72285:30:0;;;;;;;;;;;72203:124;72411:5;;;72453:12;;;-1:-1:-1;;;;;72453:12:0;;;72411:5;72526:20;;;-1:-1:-1;;;;;;72526:20:0;;;;;;;-1:-1:-1;;;;;;72595:34:0;;;;;;72647:25;;;72411:5;;;;;;8840:34:1;;;72666:5:0;;;;;8905:2:1;8890:18;;8883:43;72411:5:0;72453:12;;72647:25;;8775:18:1;72647:25:0;;;;;;;72721:12;;72688:46;;;-1:-1:-1;;;;;8858:15:1;;;8840:34;;72721:12:0;;;8905:2:1;8890:18;;8883:43;72688:46:0;;8775:18:1;72688:46:0;;;;;;;9650:1;72747:15;;;;72053:717;:::o;80613:356::-;80736:7;80761:16;:14;:16::i;:::-;;80913:48;80940:20;80913:26;:48::i;39316:252::-;39418:17;;39378:7;;-1:-1:-1;;;;;39418:17:0;:31;39468:14;:12;:14::i;:::-;39501:12;;39532:13;;39418:142;;-1:-1:-1;;;;;;39418:142:0;;;;;;;;;;11123:25:1;;;;11164:18;;;11157:34;;;;11207:18;;;11200:34;11096:18;;39418:142:0;10921:319:1;74018:354:0;74155:7;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;74180:16:::1;:14;:16::i;:::-;;74316:48;74339:24;74316:22;:48::i;88899:113::-:0;88949:4;88973:31;88994:9;88973:20;:31::i;48547:2277::-;48680:11;;:108;;-1:-1:-1;;;48680:108:0;;48662:15;;-1:-1:-1;;;;;48680:11:0;;:23;;:108;;48726:4;;48746:6;;48767:10;;48680:108;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48662:126;-1:-1:-1;48803:12:0;;48799:85;;48839:33;;-1:-1:-1;;;48839:33:0;;;;;1410:25:1;;;1383:18;;48839:33:0;1264:177:1;48799:85:0;39117:15;48972:18;;:38;48968:98;;49034:20;;-1:-1:-1;;;49034:20:0;;;;;;;;;;;48968:98;49078:23;49104:45;;;;;;;;49119:28;:26;:28::i;:::-;49104:45;;49078:71;-1:-1:-1;49758:24:0;49785:32;49798:6;49806:10;49785:12;:32::i;:::-;49758:59;;50010:18;50031:36;50036:16;50054:12;50031:4;:36::i;:::-;50010:57;;50401:10;50387:11;;:24;;;;:::i;:::-;50373:11;:38;-1:-1:-1;;;;;50446:21:0;;;;;;:13;:21;;;;;;:34;;50470:10;;50446:34;:::i;:::-;-1:-1:-1;;;;;50422:21:0;;;;;;:13;:21;;;;;;;:58;;;;50556:42;;;;;50436:6;;50569:16;;50587:10;;50556:42;:::i;:::-;;;;;;;;50614:43;;1410:25:1;;;-1:-1:-1;;;;;50614:43:0;;;50631:4;;-1:-1:-1;;;;;;;;;;;50614:43:0;1398:2:1;1383:18;50614:43:0;;;;;;;48611:2213;;;;48547:2277;;:::o;43349:889::-;43502:11;;43454:7;;43528:17;43524:707;;-1:-1:-1;;43701:27:0;;;43349:889::o;43524:707::-;43910:17;43930:14;:12;:14::i;:::-;43910:34;;43959:36;44059:13;;44027:12;;43998:9;:41;;;;:::i;:::-;:74;;;;:::i;:::-;43959:113;-1:-1:-1;44087:20:0;44171:12;44111:39;25088:4;43959:113;44111:39;:::i;:::-;44110:73;;;;:::i;:::-;44087:96;43349:889;-1:-1:-1;;;;;43349:889:0:o;43524:707::-;43468:770;43349:889;:::o;33260:1729::-;33486:11;;:123;;-1:-1:-1;;;33486:123:0;;33536:4;33486:123;;;13897:34:1;-1:-1:-1;;;;;13967:15:1;;;13947:18;;;13940:43;14019:15;;;13999:18;;;13992:43;14051:18;;;14044:34;;;33404:7:0;;;;33486:11;;;:27;;13831:19:1;;33486:123:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;33468:141;-1:-1:-1;33624:12:0;;33620:89;;33660:37;;-1:-1:-1;;;33660:37:0;;;;;1410:25:1;;;1383:18;;33660:37:0;1264:177:1;33620:89:0;33775:3;-1:-1:-1;;;;;33768:10:0;:3;-1:-1:-1;;;;;33768:10:0;;33764:70;;;33802:20;;-1:-1:-1;;;33802:20:0;;;;;;;;;;;33764:70;33911:25;33966:3;-1:-1:-1;;;;;33955:14:0;:7;-1:-1:-1;;;;;33955:14:0;;33951:169;;;-1:-1:-1;;;33951:169:0;;;-1:-1:-1;;;;;;34076:23:0;;;;;;;:18;:23;;;;;;;;:32;;;;;;;;;;33951:169;34198:20;34221:26;34241:6;34221:17;:26;:::i;:::-;-1:-1:-1;;;;;34281:18:0;;34258:20;34281:18;;;:13;:18;;;;;;34198:49;;-1:-1:-1;34258:20:0;34281:27;;34302:6;;34281:27;:::i;:::-;-1:-1:-1;;;;;34342:18:0;;34319:20;34342:18;;;:13;:18;;;;;;34258:50;;-1:-1:-1;34319:20:0;34342:27;;34363:6;;34342:27;:::i;:::-;-1:-1:-1;;;;;34503:18:0;;;;;;;:13;:18;;;;;;:33;;;34547:18;;;;;;:33;;;34319:50;-1:-1:-1;;;34653:38:0;;34649:118;;-1:-1:-1;;;;;34708:23:0;;;;;;;:18;:23;;;;;;;;:32;;;;;;;;;:47;;;34649:118;34838:3;-1:-1:-1;;;;;34824:26:0;34833:3;-1:-1:-1;;;;;34824:26:0;-1:-1:-1;;;;;;;;;;;34843:6:0;34824:26;;;;1410:25:1;;1398:2;1383:18;;1264:177;34824:26:0;;;;;;;;-1:-1:-1;9650:1:0;;33260:1729;-1:-1:-1;;;;;;;;;33260:1729:0:o;25810:174::-;25888:4;25905:18;25926:15;25931:1;25934:6;25926:4;:15::i;:::-;25905:36;;25959:17;25968:7;25959:8;:17::i;:::-;25952:24;25810:174;-1:-1:-1;;;;25810:174:0:o;89420:121::-;89476:4;89500:33;89524:9;89500:21;:33;:::i;58623:264::-;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;58706:16:::1;:14;:16::i;:::-;;58826:53;58843:10;58855;58867:11;58826:16;:53::i;:::-;-1:-1:-1::0;;84005:11:0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;58623:264::o;78817:1427::-;79060:5;;78905:7;;;;79060:5;;;-1:-1:-1;;;;;79060:5:0;79046:10;:19;79042:85;;79089:26;;-1:-1:-1;;;79089:26:0;;;;;;;;;;;79042:85;39117:15;79231:18;;:38;79227:104;;79293:26;;-1:-1:-1;;;79293:26:0;;;;;;;;;;;79227:104;79437:12;79420:14;:12;:14::i;:::-;:29;79416:101;;;79473:32;;-1:-1:-1;;;79473:32:0;;;;;;;;;;;79416:101;79617:13;;79602:12;:28;79598:98;;;79654:30;;-1:-1:-1;;;79654:30:0;;;;;;;;;;;79598:98;79864:12;79848:13;;:28;;;;:::i;:::-;79950:13;:32;;;80116:5;;79950:32;;-1:-1:-1;80102:34:0;;80116:5;;;-1:-1:-1;;;;;80116:5:0;80123:12;80102:13;:34::i;:::-;80154:54;80170:5;;;;;;;;;-1:-1:-1;;;;;80170:5:0;80177:12;80191:16;80154:54;;;;;;;;:::i;51624:278::-;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;51736:16:::1;:14;:16::i;:::-;;51845:49;51865:10;51878:1;51881:12;51845:11;:49::i;41528:851::-:0;-1:-1:-1;;;;;41746:23:0;;41632:7;41746:23;;;:14;:23;;;;;41975:24;;41971:70;;-1:-1:-1;42028:1:0;;41528:851;-1:-1:-1;;41528:851:0:o;41971:70::-;42292:11;;42265:24;;42235:27;;42265:38;;;:::i;:::-;42235:68;;42343:14;:28;;;42321:19;:50;;;;:::i;81299:1299::-;81623:5;;81411:7;;;;81623:5;;;-1:-1:-1;;;;;81623:5:0;81609:10;:19;81605:91;;81652:32;;-1:-1:-1;;;81652:32:0;;;;;;;;;;;81605:91;39117:15;81800:18;;:38;81796:110;;81862:32;;-1:-1:-1;;;81862:32:0;;;;;;;;;;;81796:110;82000:17;;;;;;;;;-1:-1:-1;;;;;82000:17:0;81977:40;;82134:20;-1:-1:-1;;;;;82134:40:0;;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;82112:120;;;;-1:-1:-1;;;82112:120:0;;8417:2:1;82112:120:0;;;8399:21:1;8456:2;8436:18;;;8429:30;8495;8475:18;;;8468:58;8543:18;;82112:120:0;8215:352:1;82112:120:0;82309:17;:40;;-1:-1:-1;;;;;;82309:40:0;-1:-1:-1;;;;;82309:40:0;;;;;;;;;82455:107;;;8858:15:1;;;8840:34;;8905:2;8890:18;;8883:43;;;;82455:107:0;;8775:18:1;82455:107:0;8572:360:1;28545:133:0;-1:-1:-1;;;;;;;;;;;;28634:36:0;;;;;;;;28649:19;28654:1;:10;;;28666:1;28649:4;:19::i;:::-;28634:36;;28627:43;28545:133;-1:-1:-1;;;28545:133:0:o;26129:208::-;26227:4;26244:18;26265:15;26270:1;26273:6;26265:4;:15::i;:::-;26244:36;;26298:31;26303:17;26312:7;26303:8;:17::i;:::-;26322:6;26298:4;:31::i;62762:736::-;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;62935:16:::1;:14;:16::i;:::-;;62964:13;62980:16;-1:-1:-1::0;;;;;62980:31:0::1;;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62964:49:::0;-1:-1:-1;63028:17:0;;63024:227:::1;;63193:46;::::0;-1:-1:-1;;;63193:46:0;;::::1;::::0;::::1;1410:25:1::0;;;1383:18;;63193:46:0::1;1264:177:1::0;63024:227:0::1;63354:136;63389:10;63414:8;63437:11;63463:16;63354:20;:136::i;:::-;-1:-1:-1::0;;84005:11:0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;-1:-1:-1;;62762:736:0:o;68481:2217::-;68706:11;;:163;;-1:-1:-1;;;68706:163:0;;68753:4;68706:163;;;15103:34:1;-1:-1:-1;;;;;15173:15:1;;;15153:18;;;15146:43;15225:15;;;15205:18;;;15198:43;15277:15;;;15257:18;;;15250:43;15309:19;;;15302:35;;;68688:15:0;;68706:11;;:24;;15037:19:1;;68706:163:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68688:181;-1:-1:-1;68884:12:0;;68880:95;;68920:43;;-1:-1:-1;;;68920:43:0;;;;;1410:25:1;;;1383:18;;68920:43:0;1264:177:1;68880:95:0;69048:10;-1:-1:-1;;;;;69036:22:0;:8;-1:-1:-1;;;;;69036:22:0;;69032:98;;;69082:36;;-1:-1:-1;;;69082:36:0;;;;;;;;;;;69032:98;69417:27;69447:99;69466:11;69492:43;;;;;;;;14572:6;69492:43;;;69447:4;:99::i;:::-;69417:129;-1:-1:-1;69557:29:0;69589:33;69417:129;69589:11;:33;:::i;:::-;69557:65;;69633:23;69659:45;;;;;;;;69674:28;:26;:28::i;:::-;69659:45;;69633:71;-1:-1:-1;69715:27:0;69745:90;69633:71;69805:19;69745:18;:90::i;:::-;69715:120;;69846:24;69889:19;69873:13;;:35;;;;:::i;:::-;70101:13;:32;;;70158:11;;69846:62;;-1:-1:-1;70158:33:0;;70172:19;;70158:33;:::i;:::-;70144:11;:47;-1:-1:-1;;;;;70228:23:0;;;;;;:13;:23;;;;;;:37;;70254:11;;70228:37;:::i;:::-;-1:-1:-1;;;;;70202:23:0;;;;;;;:13;:23;;;;;;:63;;;;70317:25;;;;;;;:62;;70358:21;;70317:62;:::i;:::-;-1:-1:-1;;;;;70276:25:0;;;;;;;:13;:25;;;;;;;:103;;;;70434:53;;;;;;-1:-1:-1;;;;;;;;;;;70434:53:0;;;70465:21;1410:25:1;;1398:2;1383:18;;1264:177;70434:53:0;;;;;;;;70503:54;;1410:25:1;;;70530:4:0;;-1:-1:-1;;;;;70503:54:0;;;-1:-1:-1;;;;;;;;;;;70503:54:0;1398:2:1;1383:18;70503:54:0;;;;;;;70573:117;70609:4;70629:19;70663:16;70573:117;;;;;;;;:::i;:::-;;;;;;;;68636:2062;;;;;;68481:2217;;;;:::o;55831:242::-;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;55910:16:::1;:14;:16::i;:::-;;56019:46;56039:10;56052:12;56019:11;:46::i;51087:245::-:0;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;51166:16:::1;:14;:16::i;:::-;;51275:49;51295:10;51308:12;51322:1;51275:11;:49::i;59126:309::-:0;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;59256:16:::1;:14;:16::i;:::-;;59376:51;59393:10;59405:8;59415:11;59376:16;:51::i;:::-;-1:-1:-1::0;;84005:11:0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;-1:-1:-1;59126:309:0:o;74636:915::-;74815:5;;74738:7;;74815:5;;;-1:-1:-1;;;;;74815:5:0;74801:10;:19;74797:87;;74844:28;;-1:-1:-1;;;74844:28:0;;;;;;;;;;;74797:87;39117:15;74969:18;;:38;74965:106;;75031:28;;-1:-1:-1;;;75031:28:0;;;;;;;;;;;74965:106;12242:4;75149:24;:51;75145:120;;;75224:29;;-1:-1:-1;;;75224:29:0;;;;;;;;;;;75145:120;75312:21;;;75344:48;;;;75410:105;;;15522:25:1;;;15578:2;15563:18;;15556:34;;;75410:105:0;;15495:18:1;75410:105:0;15348:248:1;75807:322:0;75914:7;83926:11;;;;83918:34;;;;-1:-1:-1;;;83918:34:0;;;;;;;:::i;:::-;83977:5;83963:19;;-1:-1:-1;;83963:19:0;;;75939:16:::1;:14;:16::i;:::-;;76067:28;76085:9;76067:17;:28::i;:::-;;;9650:1;76106:15;;84005:11:::0;:18;;-1:-1:-1;;84005:18:0;84019:4;84005:18;;;75807:322;;-1:-1:-1;75807:322:0:o;89782:279::-;89883:4;89934:10;-1:-1:-1;;;;;89934:18:0;;;89926:46;;;;-1:-1:-1;;;89926:46:0;;15803:2:1;89926:46:0;;;15785:21:1;15842:2;15822:18;;;15815:30;-1:-1:-1;;;15861:18:1;;;15854:45;15916:18;;89926:46:0;15601:339:1;89926:46:0;90004:6;89991:9;:19;89983:46;;;;-1:-1:-1;;;89983:46:0;;16147:2:1;89983:46:0;;;16129:21:1;16186:2;16166:18;;;16159:30;-1:-1:-1;;;16205:18:1;;;16198:44;16259:18;;89983:46:0;15945:338:1;89983:46:0;-1:-1:-1;90047:6:0;89782:279;-1:-1:-1;89782:279:0:o;29693:126::-;29752:4;29776:35;29781:17;29786:1;25088:4;29781;:17::i;:::-;29800:10;;29776:4;:35::i;25484:213::-;25666:12;;25541:4;;25666:23;;25088:4;;25666:23;:::i;59823:2545::-;60040:11;;:138;;-1:-1:-1;;;60040:138:0;;60093:4;60040:138;;;13897:34:1;-1:-1:-1;;;;;13967:15:1;;;13947:18;;;13940:43;14019:15;;;13999:18;;;13992:43;14051:18;;;14044:34;;;59955:7:0;;;;60040:11;;;:30;;13831:19:1;;60040:138:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60022:156;-1:-1:-1;60193:12:0;;60189:92;;60229:40;;-1:-1:-1;;;60229:40:0;;;;;1410:25:1;;;1383:18;;60229:40:0;1264:177:1;60189:92:0;39117:15;60369:18;;:38;60365:105;;60431:27;;-1:-1:-1;;;60431:27:0;;;;;;;;;;;60365:105;60562:26;60591:37;60619:8;60591:27;:37::i;:::-;60562:66;;60707:24;-1:-1:-1;;60734:11:0;:32;:93;;60816:11;60734:93;;;60782:18;60734:93;60707:120;;61401:25;61429:37;61442:5;61449:16;61429:12;:37::i;:::-;61401:65;-1:-1:-1;61727:25:0;61755:38;61401:65;61755:18;:38;:::i;:::-;61727:66;;61804:23;61845:17;61830:12;;:32;;;;:::i;:::-;-1:-1:-1;;;;;61945:24:0;;;;;;;:14;:24;;;;;;;;;:54;;;62051:11;;62010:38;;;;:52;62073:12;:30;;;62164:159;;16603:15:1;;;16585:34;;16635:18;;16628:43;;;;16687:18;;16680:34;;;16745:2;16730:18;;16723:34;;;16788:3;16773:19;;16766:35;;;62073:30:0;;-1:-1:-1;62164:159:0;;16534:3:1;16519:19;62164:159:0;;;;;;;-1:-1:-1;62343:17:0;;59823:2545;-1:-1:-1;;;;;;;;59823:2545:0:o;90069:216::-;90188:9;90203:2;-1:-1:-1;;;;;90203:7:0;90218:6;90203:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90187:42;;;90248:4;90240:37;;;;-1:-1:-1;;;90240:37:0;;17224:2:1;90240:37:0;;;17206:21:1;17263:2;17243:18;;;17236:30;-1:-1:-1;;;17282:18:1;;;17275:50;17342:18;;90240:37:0;17022:344:1;90240:37:0;90176:109;90069:216;;:::o;52462:3193::-;52633:19;;;:42;;-1:-1:-1;52656:19:0;;52633:42;52611:144;;;;-1:-1:-1;;;52611:144:0;;17573:2:1;52611:144:0;;;17555:21:1;17612:2;17592:18;;;17585:30;17651:34;17631:18;;;17624:62;-1:-1:-1;;;17702:18:1;;;17695:50;17762:19;;52611:144:0;17371:416:1;52611:144:0;52828:23;52854:45;;;;;;;;52869:28;:26;:28::i;:::-;52854:45;;52828:71;-1:-1:-1;52912:20:0;;53016:18;;53012:757;;53307:14;53292:29;;53351:48;53370:12;53384:14;53351:18;:48::i;:::-;53336:63;;53012:757;;;53679:34;53684:14;53700:12;53679:4;:34::i;:::-;53664:49;;53743:14;53728:29;;53012:757;53841:11;;:114;;-1:-1:-1;;;53841:114:0;;53823:15;;-1:-1:-1;;;;;53841:11:0;;:25;;:114;;53889:4;;53909:8;;53932:12;;53841:114;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53823:132;-1:-1:-1;53970:12:0;;53966:87;;54006:35;;-1:-1:-1;;;54006:35:0;;;;;1410:25:1;;;1383:18;;54006:35:0;1264:177:1;53966:87:0;39117:15;54141:18;;:38;54137:100;;54203:22;;-1:-1:-1;;;54203:22:0;;;;;;;;;;;54137:100;54335:12;54318:14;:12;:14::i;:::-;:29;54314:99;;;54371:30;;-1:-1:-1;;;54371:30:0;;;;;;;;;;;54314:99;54769:12;54755:11;;:26;;;;:::i;:::-;54741:11;:40;-1:-1:-1;;;;;54818:23:0;;;;;;:13;:23;;;;;;:38;;54844:12;;54818:38;:::i;:::-;-1:-1:-1;;;;;54792:23:0;;;;;;:13;:23;;;;;:64;55232:37;54806:8;55256:12;55232:13;:37::i;:::-;55347:47;;1410:25:1;;;55374:4:0;;-1:-1:-1;;;;;55347:47:0;;;-1:-1:-1;;;;;;;;;;;55347:47:0;1398:2:1;1383:18;55347:47:0;;;;;;;55410:44;55417:8;55427:12;55441;55410:44;;;;;;;;:::i;:::-;;;;;;;;55507:11;;:140;;-1:-1:-1;;;55507:140:0;;55554:4;55507:140;;;18457:34:1;-1:-1:-1;;;;;18527:15:1;;;18507:18;;;18500:43;18559:18;;;18552:34;;;18602:18;;;18595:34;;;55507:11:0;;;;:24;;18391:19:1;;55507:140:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52600:3055;;;;52462:3193;;;:::o;29282:90::-;29335:4;29359:5;29363:1;29359;:5;:::i;27858:90::-;27911:4;27935:5;27939:1;27935;:5;:::i;63977:3092::-;64226:11;;:187;;-1:-1:-1;;;64226:187:0;;64283:4;64226:187;;;15103:34:1;-1:-1:-1;;;;;15173:15:1;;;15153:18;;;15146:43;15225:15;;;15205:18;;;15198:43;15277:15;;;15257:18;;;15250:43;15309:19;;;15302:35;;;64208:15:0;;64226:11;;:34;;15037:19:1;;64226:187:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64208:205;-1:-1:-1;64428:12:0;;64424:90;;64464:38;;-1:-1:-1;;;64464:38:0;;;;;1410:25:1;;;1383:18;;64464:38:0;1264:177:1;64424:90:0;39117:15;64602:18;;:38;64598:103;;64664:25;;-1:-1:-1;;;64664:25:0;;;;;;;;;;;64598:103;39117:15;64806:16;-1:-1:-1;;;;;64806:35:0;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:57;64802:132;;64887:35;;-1:-1:-1;;;64887:35:0;;;;;;;;;;;64802:132;65007:10;-1:-1:-1;;;;;64995:22:0;:8;-1:-1:-1;;;;;64995:22:0;;64991:93;;;65041:31;;-1:-1:-1;;;65041:31:0;;;;;;;;;;;64991:93;65139:16;65135:84;;65179:28;;-1:-1:-1;;;65179:28:0;;;;;;;;;;;65135:84;-1:-1:-1;;65275:11:0;:32;65271:103;;;65331:31;;-1:-1:-1;;;65331:31:0;;;;;;;;;;;65271:103;65427:25;65455:101;65486:10;65511:8;65534:11;65455:16;:101::i;:::-;65820:11;;:182;;-1:-1:-1;;;65820:182:0;;65427:129;;-1:-1:-1;65771:24:0;;;;-1:-1:-1;;;;;65820:11:0;;:55;;:182;;65902:4;;65934:16;;65427:129;;65820:182;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65770:232;;;;9650:1;66035:16;:28;66013:129;;;;-1:-1:-1;;;66013:129:0;;19092:2:1;66013:129:0;;;19074:21:1;19131:2;19111:18;;;19104:30;19170:34;19150:18;;;19143:62;-1:-1:-1;;;19221:18:1;;;19214:49;19280:19;;66013:129:0;18890:415:1;66013:129:0;66250:36;;-1:-1:-1;;;66250:36:0;;-1:-1:-1;;;;;2339:32:1;;;66250:36:0;;;2321:51:1;66290:11:0;;66250:26;;;;;;2294:18:1;;66250:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:51;;66228:125;;;;-1:-1:-1;;;66228:125:0;;19720:2:1;66228:125:0;;;19702:21:1;19759:2;19739:18;;;19732:30;19798:26;19778:18;;;19771:54;19842:18;;66228:125:0;19518:348:1;66228:125:0;-1:-1:-1;;;;;66486:42:0;;66523:4;66486:42;66482:343;;;66545:63;66567:4;66574:10;66586:8;66596:11;66545:13;:63::i;:::-;66482:343;;;66667:57;;-1:-1:-1;;;66667:57:0;;9650:1;;-1:-1:-1;;;;;66667:22:0;;;;;:57;;66690:10;;66702:8;;66712:11;;66667:57;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:90;66641:172;;;;-1:-1:-1;;;66641:172:0;;20073:2:1;66641:172:0;;;20055:21:1;20112:2;20092:18;;;20085:30;-1:-1:-1;;;20131:18:1;;;20124:50;20191:18;;66641:172:0;19871:344:1;66641:172:0;66889;;;-1:-1:-1;;;;;20535:15:1;;;20517:34;;20587:15;;;20582:2;20567:18;;20560:43;20619:18;;;20612:34;;;20682:15;;20677:2;20662:18;;20655:43;20729:3;20714:19;;20707:35;;;66889:172:0;;;;;;;20466:3:1;66889:172:0;;;64152:2917;;;;63977:3092;;;;:::o;28686:121::-;28745:4;25088;28769:19;28774:1;28777;:10;;;28769:4;:19::i;:::-;:30;;;;:::i;56247:2217::-;56410:11;;:114;;-1:-1:-1;;;56410:114:0;;56392:15;;-1:-1:-1;;;;;56410:11:0;;:25;;:114;;56458:4;;56478:8;;56501:12;;56410:114;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56392:132;-1:-1:-1;56539:12:0;;56535:87;;56575:35;;-1:-1:-1;;;56575:35:0;;;;;1410:25:1;;;1383:18;;56575:35:0;1264:177:1;56535:87:0;39117:15;56710:18;;:38;56706:100;;56772:22;;-1:-1:-1;;;56772:22:0;;;;;;;;;;;56706:100;56915:12;56898:14;:12;:14::i;:::-;:29;56894:93;;;56951:24;;-1:-1:-1;;;56951:24:0;;;;;;;;;;;56894:93;57234:26;57263:37;57291:8;57263:27;:37::i;:::-;57234:66;-1:-1:-1;57311:25:0;57339:33;57360:12;57234:66;57339:33;:::i;:::-;57311:61;;57383:23;57424:12;57409;;:27;;;;:::i;:::-;-1:-1:-1;;;;;57767:24:0;;;;;;:14;:24;;;;;:54;;;57873:11;;57832:38;;;;:52;57895:12;:30;;;57383:53;-1:-1:-1;58297:37:0;57782:8;58321:12;58297:13;:37::i;:::-;58390:66;;;-1:-1:-1;;;;;21010:32:1;;20992:51;;21074:2;21059:18;;21052:34;;;21102:18;;;21095:34;;;21160:2;21145:18;;21138:34;;;58390:66:0;;20979:3:1;20964:19;58390:66:0;;;;;;;56339:2125;;;;56247:2217;;:::o;76469:1491::-;76551:7;;;;39117:15;76792:18;;:38;76788:122;;76854:44;;-1:-1:-1;;;76854:44:0;;;;;1410:25:1;;;1383:18;;76854:44:0;1264:177:1;76788:122:0;77499:35;77512:10;77524:9;77499:12;:35::i;:::-;77481:53;;77582:15;77566:13;;:31;;;;:::i;:::-;77547:50;;77690:16;77674:13;:32;;;;77795:60;77809:10;77821:15;77838:16;77795:60;;;;;;;;:::i;:::-;;;;;;;;9650:1;;77936:15;;-1:-1:-1;76469:1491:0;-1:-1:-1;;;76469:1491:0:o;30304:90::-;30357:4;30381:5;30385:1;30381;:5;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:597:1;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;452:6;449:1;446:13;443:91;;;522:1;517:2;508:6;497:9;493:22;489:31;482:42;443:91;-1:-1:-1;595:2:1;574:15;-1:-1:-1;;570:29:1;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:1:o;616:131::-;-1:-1:-1;;;;;691:31:1;;681:42;;671:70;;737:1;734;727:12;671:70;616:131;:::o;752:315::-;820:6;828;881:2;869:9;860:7;856:23;852:32;849:52;;;897:1;894;887:12;849:52;936:9;923:23;955:31;980:5;955:31;:::i;:::-;1005:5;1057:2;1042:18;;;;1029:32;;-1:-1:-1;;;752:315:1:o;1446:247::-;1505:6;1558:2;1546:9;1537:7;1533:23;1529:32;1526:52;;;1574:1;1571;1564:12;1526:52;1613:9;1600:23;1632:31;1657:5;1632:31;:::i;1698:456::-;1775:6;1783;1791;1844:2;1832:9;1823:7;1819:23;1815:32;1812:52;;;1860:1;1857;1850:12;1812:52;1899:9;1886:23;1918:31;1943:5;1918:31;:::i;:::-;1968:5;-1:-1:-1;2025:2:1;2010:18;;1997:32;2038:33;1997:32;2038:33;:::i;:::-;1698:456;;2090:7;;-1:-1:-1;;;2144:2:1;2129:18;;;;2116:32;;1698:456::o;3088:180::-;3147:6;3200:2;3188:9;3179:7;3175:23;3171:32;3168:52;;;3216:1;3213;3206:12;3168:52;-1:-1:-1;3239:23:1;;3088:180;-1:-1:-1;3088:180:1:o;3273:127::-;3334:10;3329:3;3325:20;3322:1;3315:31;3365:4;3362:1;3355:15;3389:4;3386:1;3379:15;3405:719;3448:5;3501:3;3494:4;3486:6;3482:17;3478:27;3468:55;;3519:1;3516;3509:12;3468:55;3555:6;3542:20;3581:18;3618:2;3614;3611:10;3608:36;;;3624:18;;:::i;:::-;3699:2;3693:9;3667:2;3753:13;;-1:-1:-1;;3749:22:1;;;3773:2;3745:31;3741:40;3729:53;;;3797:18;;;3817:22;;;3794:46;3791:72;;;3843:18;;:::i;:::-;3883:10;3879:2;3872:22;3918:2;3910:6;3903:18;3964:3;3957:4;3952:2;3944:6;3940:15;3936:26;3933:35;3930:55;;;3981:1;3978;3971:12;3930:55;4045:2;4038:4;4030:6;4026:17;4019:4;4011:6;4007:17;3994:54;4092:1;4085:4;4080:2;4072:6;4068:15;4064:26;4057:37;4112:6;4103:15;;;;;;3405:719;;;;:::o;4129:1108::-;4304:6;4312;4320;4328;4336;4344;4397:3;4385:9;4376:7;4372:23;4368:33;4365:53;;;4414:1;4411;4404:12;4365:53;4453:9;4440:23;4472:31;4497:5;4472:31;:::i;:::-;4522:5;-1:-1:-1;4579:2:1;4564:18;;4551:32;4592:33;4551:32;4592:33;:::i;:::-;4644:7;-1:-1:-1;4698:2:1;4683:18;;4670:32;;-1:-1:-1;4753:2:1;4738:18;;4725:32;4776:18;4806:14;;;4803:34;;;4833:1;4830;4823:12;4803:34;4856:50;4898:7;4889:6;4878:9;4874:22;4856:50;:::i;:::-;4846:60;;4959:3;4948:9;4944:19;4931:33;4915:49;;4989:2;4979:8;4976:16;4973:36;;;5005:1;5002;4995:12;4973:36;;5028:52;5072:7;5061:8;5050:9;5046:24;5028:52;:::i;:::-;5018:62;;;5132:3;5121:9;5117:19;5104:33;5181:4;5172:7;5168:18;5159:7;5156:31;5146:59;;5201:1;5198;5191:12;5146:59;5224:7;5214:17;;;4129:1108;;;;;;;;:::o;5242:403::-;5325:6;5333;5386:2;5374:9;5365:7;5361:23;5357:32;5354:52;;;5402:1;5399;5392:12;5354:52;5441:9;5428:23;5460:31;5485:5;5460:31;:::i;:::-;5510:5;-1:-1:-1;5567:2:1;5552:18;;5539:32;5580:33;5539:32;5580:33;:::i;:::-;5632:7;5622:17;;;5242:403;;;;;:::o;7209:334::-;7411:2;7393:21;;;7450:2;7430:18;;;7423:30;-1:-1:-1;;;7484:2:1;7469:18;;7462:40;7534:2;7519:18;;7209:334::o;7548:380::-;7627:1;7623:12;;;;7670;;;7691:61;;7745:4;7737:6;7733:17;7723:27;;7691:61;7798:2;7790:6;7787:14;7767:18;7764:38;7761:161;;;7844:10;7839:3;7835:20;7832:1;7825:31;7879:4;7876:1;7869:15;7907:4;7904:1;7897:15;7933:277;8000:6;8053:2;8041:9;8032:7;8028:23;8024:32;8021:52;;;8069:1;8066;8059:12;8021:52;8101:9;8095:16;8154:5;8147:13;8140:21;8133:5;8130:32;8120:60;;8176:1;8173;8166:12;11245:184;11315:6;11368:2;11356:9;11347:7;11343:23;11339:32;11336:52;;;11384:1;11381;11374:12;11336:52;-1:-1:-1;11407:16:1;;11245:184;-1:-1:-1;11245:184:1:o;11791:127::-;11852:10;11847:3;11843:20;11840:1;11833:31;11883:4;11880:1;11873:15;11907:4;11904:1;11897:15;11923:125;11963:4;11991:1;11988;11985:8;11982:34;;;11996:18;;:::i;:::-;-1:-1:-1;12033:9:1;;11923:125::o;12053:128::-;12093:3;12124:1;12120:6;12117:1;12114:13;12111:39;;;12130:18;;:::i;:::-;-1:-1:-1;12166:9:1;;12053:128::o;12503:375::-;-1:-1:-1;;;;;12761:15:1;;;12743:34;;12813:15;;;;12808:2;12793:18;;12786:43;12860:2;12845:18;;12838:34;;;;12693:2;12678:18;;12503:375::o;12883:345::-;-1:-1:-1;;;;;13103:32:1;;;;13085:51;;13167:2;13152:18;;13145:34;;;;13210:2;13195:18;;13188:34;13073:2;13058:18;;12883:345::o;13233:168::-;13273:7;13339:1;13335;13331:6;13327:14;13324:1;13321:21;13316:1;13309:9;13302:17;13298:45;13295:71;;;13346:18;;:::i;:::-;-1:-1:-1;13386:9:1;;13233:168::o;13406:217::-;13446:1;13472;13462:132;;13516:10;13511:3;13507:20;13504:1;13497:31;13551:4;13548:1;13541:15;13579:4;13576:1;13569:15;13462:132;-1:-1:-1;13608:9:1;;13406:217::o;18640:245::-;18719:6;18727;18780:2;18768:9;18759:7;18755:23;18751:32;18748:52;;;18796:1;18793;18786:12;18748:52;-1:-1:-1;;18819:16:1;;18875:2;18860:18;;;18854:25;18819:16;;18854:25;;-1:-1:-1;18640:245:1:o
Swarm Source
ipfs://c0bf655b27c753d5c126052cc8f872976ad1494ad1c3590111e53cb1d7c38efb
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 34 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|---|---|---|---|---|
| BASE | 100.00% | $1,795.82 | 0.00004556 | $0.08182 |
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.