Overview
MNT Balance
0 MNTMNT Value
$0.00View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Cross-Chain Transactions
Loading...
Loading
Contract Name:
OracleAggregatorV2
Compiler Version
v0.8.9+commit.e5eed63a
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomitePriceOracle } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomitePriceOracle.sol"; // solhint-disable-line max-line-length
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IOracleAggregatorV2 } from "./interfaces/IOracleAggregatorV2.sol";
/**
* @title OracleAggregatorV2
* @author Dolomite
*
* An implementation of the IDolomitePriceOracle interface that makes Chainlink prices compatible with the protocol.
*/
contract OracleAggregatorV2 is OnlyDolomiteMargin, IOracleAggregatorV2 {
// ========================= Constants =========================
bytes32 private constant _FILE = "OracleAggregatorV2";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
uint256 private constant _WEIGHT_TOTAL = 100;
// ========================= Storage =========================
mapping(address => TokenInfo) private _tokenInfoMap;
bool private _initialized;
// ========================= Constructor =========================
/**
* Note, these arrays are set up such that each index corresponds with one-another.
*
* @param _infos Info for each token
* @param _dolomiteMargin The address of the DolomiteMargin contract.
*/
constructor(
TokenInfo[] memory _infos,
address _dolomiteMargin
)
OnlyDolomiteMargin(_dolomiteMargin)
{
uint256 infosLength = _infos.length;
for (uint256 i; i < infosLength; ++i) {
_ownerInsertOrUpdateToken(_infos[i]);
}
}
// ========================= Admin Functions =========================
function ownerInsertOrUpdateToken(
TokenInfo memory _info
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerInsertOrUpdateToken(_info);
}
// ========================= Public Functions =========================
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory)
{
OracleInfo[] memory oracleInfos = _tokenInfoMap[_token].oracleInfos;
Require.that(
oracleInfos.length > 0,
_FILE,
"No oracles for token",
_token
);
uint256 priceTotal;
for (uint256 i; i < oracleInfos.length; ++i) {
OracleInfo memory oracleInfo = oracleInfos[i];
IDolomiteStructs.MonetaryPrice memory price = IDolomitePriceOracle(oracleInfo.oracle).getPrice(_token);
address tokenPair = oracleInfo.tokenPair;
if (tokenPair == address(0)) {
priceTotal += price.value * oracleInfo.weight;
} else {
IDolomiteStructs.MonetaryPrice memory tokenPairPrice = getPrice(tokenPair);
// Standardize the price to use 36 decimals.
uint256 tokenPairDecimals = _tokenInfoMap[tokenPair].decimals;
assert(tokenPairDecimals > 0);
uint256 tokenPairValueWith36Decimals = tokenPairPrice.value * (10 ** tokenPairDecimals);
// Now that the chained price uses 36 decimals (and thus is standardized), we can do easy math.
priceTotal += price.value * tokenPairValueWith36Decimals / _ONE_DOLLAR * oracleInfo.weight;
}
}
return IDolomiteStructs.MonetaryPrice({
value: priceTotal / _WEIGHT_TOTAL
});
}
function getTokenInfo(address _token) external view returns (TokenInfo memory) {
return _tokenInfoMap[_token];
}
function getDecimalsByToken(address _token) public view returns (uint8 _decimals) {
return _tokenInfoMap[_token].decimals;
}
function getOraclesByToken(address _token) public view returns (OracleInfo[] memory) {
return _tokenInfoMap[_token].oracleInfos;
}
// ========================= Internal Functions =========================
function _ownerInsertOrUpdateToken(
TokenInfo memory _info
) internal {
uint256 weightSum;
delete _tokenInfoMap[_info.token];
_tokenInfoMap[_info.token].token = _info.token;
_tokenInfoMap[_info.token].decimals = _info.decimals;
for (uint256 i; i < _info.oracleInfos.length; ++i) {
assert(_info.oracleInfos[i].weight > 0);
_tokenInfoMap[_info.token].oracleInfos.push(
OracleInfo({
oracle: _info.oracleInfos[i].oracle,
tokenPair: _info.oracleInfos[i].tokenPair,
weight: _info.oracleInfos[i].weight
})
);
weightSum += _info.oracleInfos[i].weight;
}
Require.that(
weightSum == _WEIGHT_TOTAL,
_FILE,
"Invalid weights"
);
emit TokenInsertedOrUpdated(_info);
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMarginForUpgradeable } from "./OnlyDolomiteMarginForUpgradeable.sol";
import { IDolomiteMargin } from "../protocol/interfaces/IDolomiteMargin.sol";
/**
* @title OnlyDolomiteMargin
* @author Dolomite
*
* @notice Inheritable contract that restricts the calling of certain functions to `DolomiteMargin`, the owner of
* `DolomiteMargin` or a `DolomiteMargin` global operator
*/
abstract contract OnlyDolomiteMargin is OnlyDolomiteMarginForUpgradeable {
// ============ Constants ============
bytes32 private constant _FILE = "OnlyDolomiteMargin";
// ============ Storage ============
IDolomiteMargin private immutable _DOLOMITE_MARGIN; // solhint-disable-line var-name-mixedcase
// ============ Constructor ============
constructor (address _dolomiteMargin) {
_DOLOMITE_MARGIN = IDolomiteMargin(_dolomiteMargin);
}
// ============ Functions ============
function DOLOMITE_MARGIN() public override view returns (IDolomiteMargin) {
return _DOLOMITE_MARGIN;
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { ProxyContractHelpers } from "./ProxyContractHelpers.sol";
import { IOnlyDolomiteMargin } from "../interfaces/IOnlyDolomiteMargin.sol";
import { IDolomiteMargin } from "../protocol/interfaces/IDolomiteMargin.sol";
import { Require } from "../protocol/lib/Require.sol";
/**
* @title OnlyDolomiteMarginForUpgradeable
* @author Dolomite
*
* @notice Inheritable contract that restricts the calling of certain functions to `DolomiteMargin`, the owner of
* `DolomiteMargin` or a `DolomiteMargin` global operator
*/
abstract contract OnlyDolomiteMarginForUpgradeable is IOnlyDolomiteMargin, ProxyContractHelpers {
// ============ Constants ============
bytes32 private constant _FILE = "OnlyDolomiteMargin";
bytes32 private constant _DOLOMITE_MARGIN_SLOT = bytes32(uint256(keccak256("eip1967.proxy.dolomiteMargin")) - 1);
// ============ Modifiers ============
modifier onlyDolomiteMargin(address _from) {
Require.that(
_from == address(DOLOMITE_MARGIN()),
_FILE,
"Only Dolomite can call function",
_from
);
_;
}
modifier onlyDolomiteMarginOwner(address _from) {
Require.that(
_from == DOLOMITE_MARGIN().owner(),
_FILE,
"Caller is not owner of Dolomite",
_from
);
_;
}
modifier onlyDolomiteMarginGlobalOperator(address _from) {
Require.that(
DOLOMITE_MARGIN().getIsGlobalOperator(_from),
_FILE,
"Caller is not a global operator",
_from
);
_;
}
// ============ Functions ============
function DOLOMITE_MARGIN() public virtual view returns (IDolomiteMargin) {
return IDolomiteMargin(_getAddress(_DOLOMITE_MARGIN_SLOT));
}
function _setDolomiteMarginViaSlot(address _dolomiteMargin) internal {
_setAddress(_DOLOMITE_MARGIN_SLOT, _dolomiteMargin);
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
/**
* @title ProxyContractHelpers
* @author Dolomite
*
* @notice Helper functions for upgradeable proxy contracts to use
*/
abstract contract ProxyContractHelpers {
// ================ Internal Functions ==================
function _callImplementation(address _implementation) internal {
// solhint-disable-next-line no-inline-assembly
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), _implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _setAddress(bytes32 slot, address _value) internal {
// solhint-disable-next-line no-inline-assembly
assembly {
sstore(slot, _value)
}
}
function _setUint256(bytes32 slot, uint256 _value) internal {
// solhint-disable-next-line no-inline-assembly
assembly {
sstore(slot, _value)
}
}
function _setUint256InMap(bytes32 slot, address key, uint256 _value) internal {
// solhint-disable-next-line no-inline-assembly
bytes32 mappingSlot = keccak256(abi.encode(key, slot));
assembly {
sstore(mappingSlot, _value)
}
}
function _setUint256InNestedMap(bytes32 slot, address key1, address key2, uint256 _value) internal {
bytes32 mappingSlot = keccak256(abi.encode(key2, keccak256(abi.encode(key1, slot))));
assembly {
sstore(mappingSlot, _value)
}
}
function _getAddress(bytes32 slot) internal view returns (address value) {
// solhint-disable-next-line no-inline-assembly
assembly {
value := sload(slot)
}
}
function _getUint256(bytes32 slot) internal view returns (uint256 value) {
// solhint-disable-next-line no-inline-assembly
assembly {
value := sload(slot)
}
}
function _getUint256FromMap(bytes32 slot, address key) internal view returns (uint256 value) {
// solhint-disable-next-line no-inline-assembly
bytes32 mappingSlot = keccak256(abi.encode(key, slot));
assembly {
value := sload(mappingSlot)
}
}
function _getUint256InNestedMap(bytes32 slot, address key1, address key2) internal view returns (uint256 value) {
bytes32 mappingSlot = keccak256(abi.encode(key2, keccak256(abi.encode(key1, slot))));
assembly {
value := sload(mappingSlot)
}
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
/**
* @title IAuthorizationBase
* @author Dolomite
*
* @notice Interface for allowing only trusted callers to invoke functions that use the `requireIsCallerAuthorized`
* modifier.
*/
interface IAuthorizationBase {
function setIsCallerAuthorized(address _caller, bool _isAuthorized) external;
function isCallerAuthorized(address _caller) external view returns (bool);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { AccountBalanceLib } from "../lib/AccountBalanceLib.sol";
/**
* @title IBorrowPositionProxyV1
* @author Dolomite
*
* @notice Interface for allowing the transfer of assets between account numbers. Emits an event to allow for easy
* indexing of a subgraph for getting active borrow positions.
*/
interface IBorrowPositionProxyV1 {
// ========================= Events =========================
event BorrowPositionOpen(address indexed _borrower, uint256 indexed _borrowAccountNumber);
// ========================= Functions =========================
/**
*
* @param _fromAccountNumber The index from which `msg.sender` will be sourcing the deposit
* @param _toAccountNumber The index into which `msg.sender` will be depositing
* @param _collateralMarketId The ID of the market being deposited
* @param _amountWei The amount, in Wei, to deposit
* @param _balanceCheckFlag Flag used to check if `_fromAccountNumber`, `_toAccountNumber`, or both accounts can
* go negative after the transfer settles. Setting the flag to
* `AccountBalanceLib.BalanceCheckFlag.None=3` results in neither account being
* checked.
*/
function openBorrowPosition(
uint256 _fromAccountNumber,
uint256 _toAccountNumber,
uint256 _collateralMarketId,
uint256 _amountWei,
AccountBalanceLib.BalanceCheckFlag _balanceCheckFlag
) external;
/**
* @notice This method can only be called once the user's debt has been reduced to zero. Sends all
* `_collateralMarketIds` from `_borrowAccountNumber` to `_toAccountNumber`.
*
* @param _borrowAccountNumber The index from which `msg.sender` collateral will be withdrawn
* @param _toAccountNumber The index into which `msg.sender` will be depositing leftover collateral
* @param _collateralMarketIds The IDs of the markets being withdrawn, to close the position
*/
function closeBorrowPosition(
uint256 _borrowAccountNumber,
uint256 _toAccountNumber,
uint256[] calldata _collateralMarketIds
) external;
/**
*
* @param _fromAccountNumber The index from which `msg.sender` will be withdrawing assets
* @param _toAccountNumber The index into which `msg.sender` will be depositing assets
* @param _marketId The ID of the market being transferred
* @param _amountWei The amount, in Wei, to transfer
* @param _balanceCheckFlag Flag used to check if `_fromAccountNumber`, `_toAccountNumber`, or both accounts can
* go negative after the transfer settles. Setting the flag to
* `AccountBalanceLib.BalanceCheckFlag.None=3` results in neither account being
* checked.
*/
function transferBetweenAccounts(
uint256 _fromAccountNumber,
uint256 _toAccountNumber,
uint256 _marketId,
uint256 _amountWei,
AccountBalanceLib.BalanceCheckFlag _balanceCheckFlag
) external;
/**
*
* @param _fromAccountNumber The index from which `msg.sender` will be depositing assets
* @param _borrowAccountNumber The index of the borrow position for that will receive the deposited assets
* @param _marketId The ID of the market being transferred
* @param _balanceCheckFlag Flag used to check if `_fromAccountNumber`, `_borrowAccountNumber`, or both accounts
* can go negative after the transfer settles. Setting the flag to
* `AccountBalanceLib.BalanceCheckFlag.None=3` results in neither account being
* checked.
*/
function repayAllForBorrowPosition(
uint256 _fromAccountNumber,
uint256 _borrowAccountNumber,
uint256 _marketId,
AccountBalanceLib.BalanceCheckFlag _balanceCheckFlag
) external;
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IAuthorizationBase } from "./IAuthorizationBase.sol";
import { IBorrowPositionProxyV1 } from "./IBorrowPositionProxyV1.sol";
import { AccountBalanceLib } from "../lib/AccountBalanceLib.sol";
/**
* @title IBorrowPositionProxyV2
* @author Dolomite
*
* @notice Interface for allowing only trusted callers to invoke borrow related functions for transferring funds
* between account owners.
*/
interface IBorrowPositionProxyV2 is IAuthorizationBase, IBorrowPositionProxyV1 {
// ========================= Functions =========================
/**
*
* @param _fromAccountOwner The account from which the user will be sourcing the deposit
* @param _fromAccountNumber The index from which `_toAccountOwner` will be sourcing the deposit
* @param _toAccountOwner The account into which `_fromAccountOwner` will be depositing
* @param _toAccountNumber The index into which `_fromAccountOwner` will be depositing
* @param _collateralMarketId The ID of the market being deposited
* @param _amountWei The amount, in Wei, to deposit
* @param _balanceCheckFlag Flag used to check if `_fromAccountNumber`, `_toAccountNumber`, or both accounts can
* go negative after the transfer settles. Setting the flag to
* `AccountBalanceLib.BalanceCheckFlag.None=3` results in neither account being
* checked.
*/
function openBorrowPositionWithDifferentAccounts(
address _fromAccountOwner,
uint256 _fromAccountNumber,
address _toAccountOwner,
uint256 _toAccountNumber,
uint256 _collateralMarketId,
uint256 _amountWei,
AccountBalanceLib.BalanceCheckFlag _balanceCheckFlag
) external;
/**
* @notice This method can only be called once the user's debt has been reduced to zero. Sends all
* `_collateralMarketIds` from `_borrowAccountNumber` to `_toAccountNumber`.
*
* @param _borrowAccountOwner The account from which collateral will be withdrawn
* @param _borrowAccountNumber The index from which `msg.sender` collateral will be withdrawn
* @param _toAccountOwner The account into which `_borrowAccountOwner` will be depositing leftover collateral
* @param _toAccountNumber The index into which `_borrowAccountOwner` will be depositing leftover collateral
* @param _collateralMarketIds The IDs of the markets being withdrawn, to close the position
*/
function closeBorrowPositionWithDifferentAccounts(
address _borrowAccountOwner,
uint256 _borrowAccountNumber,
address _toAccountOwner,
uint256 _toAccountNumber,
uint256[] calldata _collateralMarketIds
) external;
/**
*
* @param _fromAccountOwner The account from which assets will be withdrawn
* @param _fromAccountNumber The index from which `msg.sender` will be withdrawing assets
* @param _toAccountOwner The account to which assets will be deposited
* @param _toAccountNumber The index into which `msg.sender` will be depositing assets
* @param _marketId The ID of the market being transferred
* @param _amountWei The amount, in Wei, to transfer
* @param _balanceCheckFlag Flag used to check if `_fromAccountNumber`, `_toAccountNumber`, or both accounts can
* go negative after the transfer settles. Setting the flag to
* `AccountBalanceLib.BalanceCheckFlag.None=3` results in neither account being
* checked.
*/
function transferBetweenAccountsWithDifferentAccounts(
address _fromAccountOwner,
uint256 _fromAccountNumber,
address _toAccountOwner,
uint256 _toAccountNumber,
uint256 _marketId,
uint256 _amountWei,
AccountBalanceLib.BalanceCheckFlag _balanceCheckFlag
) external;
/**
*
* @param _fromAccountOwner The account from which assets will be withdrawn for repayment
* @param _fromAccountNumber The index from which `msg.sender` will be depositing assets
* @param _borrowAccountOwner The account of the borrow position that will receive the deposited assets
* @param _borrowAccountNumber The index of the borrow position for that will receive the deposited assets
* @param _marketId The ID of the market being transferred
* @param _balanceCheckFlag Flag used to check if `_fromAccountNumber`, `_borrowAccountNumber`, or both accounts
* can go negative after the transfer settles. Setting the flag to
* `AccountBalanceLib.BalanceCheckFlag.None=3` results in neither account being
* checked.
*/
function repayAllForBorrowPositionWithDifferentAccounts(
address _fromAccountOwner,
uint256 _fromAccountNumber,
address _borrowAccountOwner,
uint256 _borrowAccountNumber,
uint256 _marketId,
AccountBalanceLib.BalanceCheckFlag _balanceCheckFlag
) external;
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteStructs } from "../protocol/interfaces/IDolomiteStructs.sol";
/**
* @title IDolomiteMigrator
* @author Dolomite
*
* Interface for a migrator contract, which can migrate funds out of users isolation mode vaults
*/
interface IDolomiteMigrator {
// ================================================
// ==================== Structs ===================
// ================================================
struct Transformer {
address transformer;
bool soloAllowable;
}
// ================================================
// ==================== Events ====================
// ================================================
event MigrationComplete(
address indexed _accountOwner,
uint256 _accountNumber,
uint256 _fromMarketId,
uint256 _toMarketId
);
event TransformerSet(uint256 _fromMarketId, uint256 _toMarketId, address _transformer);
event HandlerSet(address _handler);
// ================================================
// ================== Functions ===================
// ================================================
function migrate(
IDolomiteStructs.AccountInfo[] calldata _accounts,
uint256 _fromMarketId,
uint256 _toMarketId,
bytes calldata _extraData
) external;
function selfMigrate(
uint256 _accountNumber,
uint256 _fromMarketId,
uint256 _toMarketId,
bytes calldata _extraData
) external;
function ownerSetTransformer(
uint256 _fromMarketId,
uint256 _toMarketId,
address _transformer,
bool _soloAllowable
) external;
function ownerSetHandler(address _handler) external;
function getTransformerByMarketIds(
uint256 _fromMarketId,
uint256 _toMarketId
) external view returns (Transformer memory);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteMigrator } from "./IDolomiteMigrator.sol";
import { IEventEmitterRegistry } from "./IEventEmitterRegistry.sol";
import { IExpiry } from "./IExpiry.sol";
import { IGenericTraderProxyV1 } from "./IGenericTraderProxyV1.sol";
import { ILiquidatorAssetRegistry } from "./ILiquidatorAssetRegistry.sol";
import { IDolomitePriceOracle } from "../protocol/interfaces/IDolomitePriceOracle.sol";
/**
* @title IDolomiteRegistry
* @author Dolomite
*
* @notice A registry contract for storing all of the addresses that can interact with Umami's Delta Neutral vaults
*/
interface IDolomiteRegistry {
// ========================================================
// ======================== Events ========================
// ========================================================
event GenericTraderProxySet(address indexed _genericTraderProxy);
event ExpirySet(address indexed _expiry);
event SlippageToleranceForPauseSentinelSet(uint256 _slippageTolerance);
event LiquidatorAssetRegistrySet(address indexed _liquidatorAssetRegistry);
event EventEmitterSet(address indexed _eventEmitter);
event ChainlinkPriceOracleSet(address indexed _chainlinkPriceOracle);
event DolomiteMigratorSet(address indexed _dolomiteMigrator);
event RedstonePriceOracleSet(address indexed _redstonePriceOracle);
event OracleAggregatorSet(address indexed _oracleAggregator);
// ========================================================
// =================== Write Functions ====================
// ========================================================
function lazyInitialize(address _dolomiteMigrator, address _oracleAggregator) external;
/**
*
* @param _genericTraderProxy The new address of the generic trader proxy
*/
function ownerSetGenericTraderProxy(address _genericTraderProxy) external;
/**
*
* @param _expiry The new address of the expiry contract
*/
function ownerSetExpiry(address _expiry) external;
/**
*
* @param _slippageToleranceForPauseSentinel The slippage tolerance (using 1e18 as the base) for zaps when pauses
* are enabled
*/
function ownerSetSlippageToleranceForPauseSentinel(uint256 _slippageToleranceForPauseSentinel) external;
/**
*
* @param _liquidatorRegistry The new address of the liquidator registry
*/
function ownerSetLiquidatorAssetRegistry(address _liquidatorRegistry) external;
/**
*
* @param _eventEmitter The new address of the event emitter
*/
function ownerSetEventEmitter(address _eventEmitter) external;
/**
*
* @param _chainlinkPriceOracle The new address of the Chainlink price oracle that's compatible with
* DolomiteMargin.
*/
function ownerSetChainlinkPriceOracle(address _chainlinkPriceOracle) external;
function ownerSetDolomiteMigrator(address _dolomiteMigrator) external;
/**
*
* @param _redstonePriceOracle The new address of the Redstone price oracle that's compatible with
* DolomiteMargin.
*/
function ownerSetRedstonePriceOracle(address _redstonePriceOracle) external;
/**
*
* @param _oracleAggregator The new address of the oracle aggregator that's compatible with
* DolomiteMargin.
*/
function ownerSetOracleAggregator(address _oracleAggregator) external;
// ========================================================
// =================== Getter Functions ===================
// ========================================================
/**
* @return The address of the generic trader proxy for making zaps
*/
function genericTraderProxy() external view returns (IGenericTraderProxyV1);
/**
* @return The address of the expiry contract
*/
function expiry() external view returns (IExpiry);
/**
* @return The slippage tolerance (using 1e18 as the base) for zaps when pauses are enabled
*/
function slippageToleranceForPauseSentinel() external view returns (uint256);
/**
* @return The address of the liquidator asset registry contract
*/
function liquidatorAssetRegistry() external view returns (ILiquidatorAssetRegistry);
/**
* @return The address of the emitter contract that can emit certain events for indexing
*/
function eventEmitter() external view returns (IEventEmitterRegistry);
/**
* @return The address of the Chainlink price oracle that's compatible with DolomiteMargin
*/
function chainlinkPriceOracle() external view returns (IDolomitePriceOracle);
/**
* @return The address of the migrator contract
*/
function dolomiteMigrator() external view returns (IDolomiteMigrator);
/**
* @return The address of the Redstone price oracle that's compatible with DolomiteMargin
*/
function redstonePriceOracle() external view returns (IDolomitePriceOracle);
/**
* @return The address of the oracle aggregator that's compatible with DolomiteMargin
*/
function oracleAggregator() external view returns (IDolomitePriceOracle);
/**
* @return The base (denominator) for the slippage tolerance variable. Always 1e18.
*/
function slippageToleranceForPauseSentinelBase() external pure returns (uint256);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IGenericTraderBase } from "./IGenericTraderBase.sol";
import { IUpgradeableAsyncIsolationModeUnwrapperTrader } from "../isolation-mode/interfaces/IUpgradeableAsyncIsolationModeUnwrapperTrader.sol"; // solhint-disable-line max-line-length
import { IUpgradeableAsyncIsolationModeWrapperTrader } from "../isolation-mode/interfaces/IUpgradeableAsyncIsolationModeWrapperTrader.sol"; // solhint-disable-line max-line-length
import { IDolomiteStructs } from "../protocol/interfaces/IDolomiteStructs.sol";
/**
* @title IEventEmitterRegistry
* @author Dolomite
*
* Interface for a a singleton event emission contract, which makes tracking events easier for the Subgraph.
*/
interface IEventEmitterRegistry {
// ================================================
// ==================== Structs ===================
// ================================================
struct BalanceUpdate {
IDolomiteStructs.Wei deltaWei;
IDolomiteStructs.Par newPar;
}
// ================================================
// ==================== Events ====================
// ================================================
/**
* @notice This is emitted when a zap is executed
*
* @param accountOwner The address of the account that executed the zap
* @param accountNumber The sub account of the address that executed the zap
* @param marketIdsPath The path of market IDs that was executed
* @param tradersPath The path of traders that was executed
*/
event ZapExecuted(
address indexed accountOwner,
uint256 accountNumber,
uint256[] marketIdsPath,
IGenericTraderBase.TraderParam[] tradersPath
);
/**
* @notice This is emitted when a borrow position is initially opened
*
* @param borrower The address of the account that opened the position
* @param borrowAccountNumber The account number of the account that opened the position
*/
event BorrowPositionOpen(
address indexed borrower,
uint256 indexed borrowAccountNumber
);
/**
* @notice This is emitted when a margin position is initially opened
*
* @param accountOwner The address of the account that opened the position
* @param accountNumber The account number of the account that opened the position
* @param inputToken The token that was sold to purchase the collateral. This should be the owed token
* @param outputToken The token that was purchased with the debt. This should be the held token
* @param depositToken The token that was deposited as collateral. This should be the held token
* @param inputBalanceUpdate The amount of inputToken that was sold to purchase the outputToken
* @param outputBalanceUpdate The amount of outputToken that was purchased with the inputToken
* @param marginDepositUpdate The amount of depositToken that was deposited as collateral
*/
event MarginPositionOpen(
address indexed accountOwner,
uint256 indexed accountNumber,
address inputToken,
address outputToken,
address depositToken,
BalanceUpdate inputBalanceUpdate,
BalanceUpdate outputBalanceUpdate,
BalanceUpdate marginDepositUpdate
);
/**
* @notice This is emitted when a margin position is (partially) closed
*
* @param accountOwner The address of the account that opened the position
* @param accountNumber The account number of the account that opened the position
* @param inputToken The token that was sold to purchase the debt. This should be the held token
* @param outputToken The token that was purchased with the collateral. This should be the owed token
* @param withdrawalToken The token that was withdrawn as collateral. This should be the held token
* @param inputBalanceUpdate The amount of inputToken that was sold to purchase the outputToken
* @param outputBalanceUpdate The amount of outputToken that was purchased with the inputToken
* @param marginWithdrawalUpdate The amount of withdrawalToken that was deposited as collateral
*/
event MarginPositionClose(
address indexed accountOwner,
uint256 indexed accountNumber,
address inputToken,
address outputToken,
address withdrawalToken,
BalanceUpdate inputBalanceUpdate,
BalanceUpdate outputBalanceUpdate,
BalanceUpdate marginWithdrawalUpdate
);
event AsyncDepositCreated(
bytes32 indexed key,
address indexed token,
IUpgradeableAsyncIsolationModeWrapperTrader.DepositInfo deposit
);
event AsyncDepositOutputAmountUpdated(
bytes32 indexed key,
address indexed token,
uint256 outputAmount
);
event AsyncDepositExecuted(bytes32 indexed key, address indexed token);
event AsyncDepositFailed(bytes32 indexed key, address indexed token, string reason);
event AsyncDepositCancelled(bytes32 indexed key, address indexed token);
event AsyncDepositCancelledFailed(bytes32 indexed key, address indexed token, string reason);
event AsyncWithdrawalCreated(
bytes32 indexed key,
address indexed token,
IUpgradeableAsyncIsolationModeUnwrapperTrader.WithdrawalInfo withdrawal
);
event AsyncWithdrawalOutputAmountUpdated(
bytes32 indexed key,
address indexed token,
uint256 outputAmount
);
event AsyncWithdrawalExecuted(bytes32 indexed key, address indexed token);
event AsyncWithdrawalFailed(bytes32 indexed key, address indexed token, string reason);
event AsyncWithdrawalCancelled(bytes32 indexed key, address indexed token);
event RewardClaimed(
address indexed distributor,
address indexed user,
uint256 epoch,
uint256 amount
);
// ================================================
// ================== Functions ===================
// ================================================
/**
* @notice Emits a ZapExecuted event
*
* @param _accountOwner The address of the account that executed the zap
* @param _accountNumber The sub account of the address that executed the zap
* @param _marketIdsPath The path of market IDs that was executed
* @param _tradersPath The path of traders that was executed
*/
function emitZapExecuted(
address _accountOwner,
uint256 _accountNumber,
uint256[] calldata _marketIdsPath,
IGenericTraderBase.TraderParam[] calldata _tradersPath
)
external;
/**
* @notice Emits a MarginPositionOpen event
*
* @param _accountOwner The address of the account that opened the position
* @param _accountNumber The account number of the account that opened the position
*/
function emitBorrowPositionOpen(
address _accountOwner,
uint256 _accountNumber
)
external;
/**
* @notice Emits a MarginPositionOpen event
*
* @param _accountOwner The address of the account that opened the position
* @param _accountNumber The account number of the account that opened the position
* @param _inputToken The token that was sold to purchase the collateral. This should be the owed token
* @param _outputToken The token that was purchased with the debt. This should be the held token
* @param _depositToken The token that was deposited as collateral. This should be the held token
* @param _inputBalanceUpdate The amount of inputToken that was sold to purchase the outputToken
* @param _outputBalanceUpdate The amount of outputToken that was purchased with the inputToken
* @param _marginDepositUpdate The amount of depositToken that was deposited as collateral
*/
function emitMarginPositionOpen(
address _accountOwner,
uint256 _accountNumber,
address _inputToken,
address _outputToken,
address _depositToken,
BalanceUpdate calldata _inputBalanceUpdate,
BalanceUpdate calldata _outputBalanceUpdate,
BalanceUpdate calldata _marginDepositUpdate
)
external;
/**
* @notice Emits a MarginPositionClose event
*
* @param _accountOwner The address of the account that opened the position
* @param _accountNumber The account number of the account that opened the position
* @param _inputToken The token that was sold to purchase the debt. This should be the held token
* @param _outputToken The token that was purchased with the collateral. This should be the owed token
* @param _withdrawalToken The token that was withdrawn as collateral. This should be the held token
* @param _inputBalanceUpdate The amount of inputToken that was sold to purchase the outputToken
* @param _outputBalanceUpdate The amount of outputToken that was purchased with the inputToken
* @param _marginWithdrawalUpdate The amount of withdrawalToken that was deposited as collateral
*/
function emitMarginPositionClose(
address _accountOwner,
uint256 _accountNumber,
address _inputToken,
address _outputToken,
address _withdrawalToken,
BalanceUpdate calldata _inputBalanceUpdate,
BalanceUpdate calldata _outputBalanceUpdate,
BalanceUpdate calldata _marginWithdrawalUpdate
)
external;
function emitAsyncDepositCreated(
bytes32 _key,
address _token,
IUpgradeableAsyncIsolationModeWrapperTrader.DepositInfo calldata _deposit
) external;
function emitAsyncDepositOutputAmountUpdated(
bytes32 _key,
address _token,
uint256 _outputAmount
) external;
function emitAsyncDepositExecuted(bytes32 _key, address _token) external;
function emitAsyncDepositFailed(bytes32 _key, address _token, string calldata _reason) external;
function emitAsyncDepositCancelled(bytes32 _key, address _token) external;
function emitAsyncDepositCancelledFailed(bytes32 _key, address _token, string calldata _reason) external;
function emitAsyncWithdrawalCreated(
bytes32 _key,
address _token,
IUpgradeableAsyncIsolationModeUnwrapperTrader.WithdrawalInfo calldata _withdrawal
) external;
function emitAsyncWithdrawalOutputAmountUpdated(
bytes32 _key,
address _token,
uint256 _outputAmount
) external;
function emitAsyncWithdrawalExecuted(bytes32 _key, address _token) external;
function emitAsyncWithdrawalFailed(bytes32 _key, address _token, string calldata _reason) external;
function emitAsyncWithdrawalCancelled(bytes32 _key, address _token) external;
function emitRewardClaimed(address user, uint256 _epoch, uint256 _amount) external;
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteMargin } from "../protocol/interfaces/IDolomiteMargin.sol";
/**
* @title IExpiry
* @author Dolomite
*
* @notice Interface for getting, setting, and executing the expiry of a position.
*/
interface IExpiry {
// ============ Enums ============
enum CallFunctionType {
SetExpiry,
SetApproval
}
// ============ Structs ============
struct SetExpiryArg {
IDolomiteMargin.AccountInfo account;
uint256 marketId;
uint32 timeDelta;
bool forceUpdate;
}
struct SetApprovalArg {
address sender;
uint32 minTimeDelta;
}
function getSpreadAdjustedPrices(
uint256 heldMarketId,
uint256 owedMarketId,
uint32 expiry
)
external
view
returns (IDolomiteMargin.MonetaryPrice memory heldPrice, IDolomiteMargin.MonetaryPrice memory owedPriceAdj);
function getExpiry(
IDolomiteMargin.AccountInfo calldata account,
uint256 marketId
)
external
view
returns (uint32);
function g_expiryRampTime() external view returns (uint256);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteMargin } from "../protocol/interfaces/IDolomiteMargin.sol";
/**
* @title IGenericTraderBase
* @author Dolomite
*
* @notice Base contract structs/params for a generic trader contract.
*/
interface IGenericTraderBase {
// ============ Enums ============
enum TraderType {
/// @dev The trade will be conducted using external liquidity, using an `ActionType.Sell` or `ActionType.Buy`
/// action.
ExternalLiquidity,
/// @dev The trade will be conducted using internal liquidity, using an `ActionType.Trade` action.
InternalLiquidity,
/// @dev The trade will be conducted using external liquidity using an `ActionType.Sell` or `ActionType.Buy`
/// action. If this TradeType is used, the trader must be validated using
/// the `IIsolationModeToken#isTokenConverterTrusted` function on the IsolationMode token.
IsolationModeUnwrapper,
/// @dev The trade will be conducted using external liquidity using an `ActionType.Sell` or `ActionType.Buy`
/// action. If this TradeType is used, the trader must be validated using
/// the `IIsolationModeToken#isTokenConverterTrusted` function on the IsolationMode token.
IsolationModeWrapper
}
// ============ Structs ============
struct TraderParam {
/// @dev The type of trade to conduct
TraderType traderType;
/// @dev The index into the `_makerAccounts` array of the maker account to trade with. Should be set to 0 if
/// the traderType is not `TraderType.InternalLiquidity`.
uint256 makerAccountIndex;
/// @dev The address of IAutoTrader or IExchangeWrapper that will be used to conduct the trade.
address trader;
/// @dev The data that will be passed through to the trader contract.
bytes tradeData;
}
struct GenericTraderProxyCache {
IDolomiteMargin dolomiteMargin;
/// @dev True if the user is making a margin deposit, false if they are withdrawing. False if the variable is
/// unused too.
bool isMarginDeposit;
/// @dev The other account number that is not `_traderAccountNumber`. Only used for TransferCollateralParams.
uint256 otherAccountNumber;
/// @dev The index into the account array at which traders start.
uint256 traderAccountStartIndex;
/// @dev The cursor for the looping through the operation's actions.
uint256 actionsCursor;
/// @dev The balance of `inputMarket` that the trader has before the call to `dolomiteMargin.operate`
IDolomiteMargin.Wei inputBalanceWeiBeforeOperate;
/// @dev The balance of `outputMarket` that the trader has before the call to `dolomiteMargin.operate`
IDolomiteMargin.Wei outputBalanceWeiBeforeOperate;
/// @dev The balance of `transferMarket` that the trader has before the call to `dolomiteMargin.operate`
IDolomiteMargin.Wei transferBalanceWeiBeforeOperate;
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IGenericTraderBase } from "./IGenericTraderBase.sol";
import { AccountBalanceLib } from "../lib/AccountBalanceLib.sol";
import { IDolomiteMargin } from "../protocol/interfaces/IDolomiteMargin.sol";
/**
* @title IGenericTraderProxyV1
* @author Dolomite
*
* Trader proxy interface for trading assets using any trader from msg.sender
*/
interface IGenericTraderProxyV1 is IGenericTraderBase {
// ============ Structs ============
enum EventEmissionType {
None,
BorrowPosition,
MarginPosition
}
struct TransferAmount {
/// @dev The market ID to transfer
uint256 marketId;
/// @dev Note, setting to uint(-1) will transfer all of the user's balance.
uint256 amountWei;
}
struct TransferCollateralParam {
/// @dev The account number from which collateral will be transferred.
uint256 fromAccountNumber;
/// @dev The account number to which collateral will be transferred.
uint256 toAccountNumber;
/// @dev The transfers to execute after all of the trades.
TransferAmount[] transferAmounts;
}
struct ExpiryParam {
/// @dev The market ID whose expiry will be updated.
uint256 marketId;
/// @dev The new expiry time delta for the market. Setting this to `0` will reset the expiration.
uint32 expiryTimeDelta;
}
struct UserConfig {
/// @dev The timestamp at which the zap request fails
uint256 deadline;
/// @dev Setting this to `BalanceCheckFlag.Both` or `BalanceCheckFlag.From` will check the
/// `_tradeAccountNumber` is not negative after the trade for the input market (_marketIdsPath[0]).
/// Setting this to `BalanceCheckFlag.Both` or `BalanceCheckFlag.To` will check the
/// `_transferAccountNumber` is not negative after the trade for any of the transfers in
/// `TransferCollateralParam.transferAmounts`.
AccountBalanceLib.BalanceCheckFlag balanceCheckFlag;
EventEmissionType eventType;
}
// ============ Functions ============
/**
* @dev Swaps an exact amount of input for a minimum amount of output.
*
* @param _tradeAccountNumber The account number to use for msg.sender's trade
* @param _marketIdsPath The path of market IDs to use for each trade action. Length should be equal
* to `_tradersPath.length + 1`.
* @param _inputAmountWei The input amount (in wei) to use for the initial trade action. Setting this
* value to `uint(-1)` will use the user's full balance.
* @param _minOutputAmountWei The minimum output amount expected to be received by the user.
* @param _tradersPath The path of traders to use for each trade action. Length should be equal to
* `_marketIdsPath.length - 1`.
* @param _makerAccounts The accounts that will be used for the maker side of the trades involving
* `TraderType.InternalLiquidity`.
* @param _userConfig The user configuration for the trade. Setting the `balanceCheckFlag` to
* `BalanceCheckFlag.From` will check that the user's `_tradeAccountNumber`
* is non-negative after the trade. Setting the `balanceCheckFlag` to
* `BalanceCheckFlag.To` has no effect.
*/
function swapExactInputForOutput(
uint256 _tradeAccountNumber,
uint256[] calldata _marketIdsPath,
uint256 _inputAmountWei,
uint256 _minOutputAmountWei,
IGenericTraderBase.TraderParam[] calldata _tradersPath,
IDolomiteMargin.AccountInfo[] calldata _makerAccounts,
UserConfig calldata _userConfig
)
external;
/**
* @dev The same function as `swapExactInputForOutput`, but allows the caller to transfer collateral and modify
* the position's expiration in the same transaction.
*
* @param _tradeAccountNumber The account number to use for msg.sender's trade
* @param _marketIdsPath The path of market IDs to use for each trade action. Length should be equal
* to `_tradersPath.length + 1`.
* @param _inputAmountWei The input amount (in wei) to use for the initial trade action. Setting this
* value to `uint(-1)` will use the user's full balance.
* @param _minOutputAmountWei The minimum output amount expected to be received by the user.
* @param _tradersPath The path of traders to use for each trade action. Length should be equal to
* `_marketIdsPath.length - 1`.
* @param _makerAccounts The accounts that will be used for the maker side of the trades involving
`TraderType.InternalLiquidity`.
* @param _transferCollateralParams The parameters for transferring collateral in/out of the
* `_tradeAccountNumber` once the trades settle. One of
* `_params.fromAccountNumber` or `_params.toAccountNumber` must be equal to
* `_tradeAccountNumber`.
* @param _expiryParams The parameters for modifying the expiration of the debt in the position.
* @param _userConfig The user configuration for the trade. Setting the `balanceCheckFlag` to
* `BalanceCheckFlag.From` will check that the user's balance for inputMarket
* for `_tradeAccountNumber` is non-negative after the trade. Setting the
* `balanceCheckFlag` to `BalanceCheckFlag.To` will check that the user's
* balance for each `transferMarket` for `transferAccountNumber` is
* non-negative after.
*/
function swapExactInputForOutputAndModifyPosition(
uint256 _tradeAccountNumber,
uint256[] calldata _marketIdsPath,
uint256 _inputAmountWei,
uint256 _minOutputAmountWei,
IGenericTraderBase.TraderParam[] calldata _tradersPath,
IDolomiteMargin.AccountInfo[] calldata _makerAccounts,
TransferCollateralParam calldata _transferCollateralParams,
ExpiryParam calldata _expiryParams,
UserConfig calldata _userConfig
)
external;
function ownerSetEventEmitterRegistry(
address _eventEmitterRegistry
) external;
function EXPIRY() external view returns (address);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
/**
* @title ILiquidatorAssetRegistry
* @author Dolomite
*
* Interface for a registry that tracks which assets can be liquidated and by each contract
*/
interface ILiquidatorAssetRegistry {
/**
*
* @param _marketId The market ID of the asset
* @param _liquidator The address of the liquidator to add
*/
function ownerAddLiquidatorToAssetWhitelist(
uint256 _marketId,
address _liquidator
)
external;
/**
*
* @param _marketId The market ID of the asset
* @param _liquidator The address of the liquidator to remove
*/
function ownerRemoveLiquidatorFromAssetWhitelist(
uint256 _marketId,
address _liquidator
)
external;
/**
*
* @param _marketId The market ID of the asset to check
* @return An array of whitelisted liquidators for the asset. An empty array is returned if any
* liquidator can be used for this asset
*/
function getLiquidatorsForAsset(
uint256 _marketId
)
external view returns (address[] memory);
/**
*
* @param _marketId The market ID of the asset to check
* @param _liquidator The address of the liquidator to check
* @return True if the liquidator is whitelisted for the asset, false otherwise. Returns true if there
* are no whitelisted liquidators for the asset. Should ALWAYS have at least ONE whitelisted
* liquidator for IsolationMode assets.
*/
function isAssetWhitelistedForLiquidation(
uint256 _marketId,
address _liquidator
)
external view returns (bool);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteMargin } from "../protocol/interfaces/IDolomiteMargin.sol";
/**
* @title IOnlyDolomiteMargin
* @author Dolomite
*
* @notice This interface is for contracts that need to add modifiers for only DolomiteMargin / Owner caller.
*/
interface IOnlyDolomiteMargin {
function DOLOMITE_MARGIN() external view returns (IDolomiteMargin);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteMargin } from "../../protocol/interfaces/IDolomiteMargin.sol";
import { IDolomiteMarginExchangeWrapper } from "../../protocol/interfaces/IDolomiteMarginExchangeWrapper.sol";
/**
* @title IIsolationModeUnwrapperTraderV2
* @author Dolomite
*
* V2 Interface for a contract that can convert an isolation mode token into an underlying component token.
*/
interface IIsolationModeUnwrapperTraderV2 is IDolomiteMarginExchangeWrapper {
struct CreateActionsForUnwrappingParams {
/// @dev The index of the account (according the Accounts[] array) that is performing the sell.
uint256 primaryAccountId;
/// @dev The index of the account (according the Accounts[] array) that is being liquidated. This is set to
/// `_primaryAccountId` if a liquidation is not occurring.
uint256 otherAccountId;
/// @dev The address of the owner of the account that is performing the sell.
address primaryAccountOwner;
/// @dev The account number of the owner of the account that is performing the sell.
uint256 primaryAccountNumber;
/// @dev The address of the owner of the account that is being liquidated. This is set to
/// `_primaryAccountOwner` if a liquidation is not occurring.
address otherAccountOwner;
/// @dev The account number of the owner of the account that is being liquidated. This is set to
/// `_primaryAccountNumber` if a liquidation is not occurring.
uint256 otherAccountNumber;
/// @dev The market that is being outputted by the unwrapping.
uint256 outputMarket;
/// @dev The market that is being unwrapped, should be equal to `token()`.
uint256 inputMarket;
/// @dev The min amount of `_outputMarket` that must be outputted by the unwrapping.
uint256 minOutputAmount;
/// @dev The amount of the `_inputMarket` that the _primaryAccountId must sell.
uint256 inputAmount;
/// @dev The calldata to pass through to any external sales that occur.
bytes orderData;
}
/**
* @return The isolation mode token that this contract can unwrap (the input token).
*/
function token() external view returns (address);
/**
* @return True if the `_outputToken` is a valid output token for this contract, to be unwrapped by `token()`.
*/
function isValidOutputToken(address _outputToken) external view returns (bool);
/**
* @notice Creates the necessary actions for selling the `_inputMarket` into `_outputMarket`. Note, the
* `_inputMarket` should be equal to `token()` and `_outputMarket` should be validated to be a correct
* market that can be transformed into `token()`.
*
* @param _params The parameters for creating the actions for unwrapping.
* @return The actions that will be executed to unwrap the `_inputMarket` into `_outputMarket`.
*/
function createActionsForUnwrapping(
CreateActionsForUnwrappingParams calldata _params
)
external
view
returns (IDolomiteMargin.ActionArgs[] memory);
/**
* @return The number of actions used to unwrap the isolation mode token.
*/
function actionsLength() external view returns (uint256);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IBorrowPositionProxyV2 } from "../../interfaces/IBorrowPositionProxyV2.sol";
import { IOnlyDolomiteMargin } from "../../interfaces/IOnlyDolomiteMargin.sol";
/**
* @title IIsolationModeVaultFactory
* @author Dolomite
*
* @notice A wrapper contract around a certain token to offer isolation mode features for DolomiteMargin.
*/
interface IIsolationModeVaultFactory is IOnlyDolomiteMargin {
// =================================================
// ==================== Structs ====================
// =================================================
struct QueuedTransfer {
address from;
address to;
uint256 amount;
address vault;
bool isExecuted;
}
// ================================================
// ==================== Events ====================
// ================================================
event UserVaultImplementationSet(
address indexed previousUserVaultImplementation,
address indexed newUserVaultImplementation
);
event TokenConverterSet(address indexed tokenConverter, bool isTrusted);
event VaultCreated(address indexed account, address vault);
event Initialized();
event TransferQueued(
uint256 indexed transferCursor,
address from,
address to,
uint256 amountWei,
address vault
);
// ======================================================
// ================== Admin Functions ===================
// ======================================================
/**
* @notice Initializes this contract's variables that are dependent on this token being added to DolomiteMargin.
*/
function ownerInitialize(address[] calldata _tokenConverters) external;
/**
*
* @param _userVaultImplementation The address of the new vault implementation contract
*/
function ownerSetUserVaultImplementation(address _userVaultImplementation) external;
/**
* @notice A token converter is used to convert this underlying token into a Dolomite-compatible one for deposit
* or withdrawal
*
* @param _tokenConverter The address of the token converter contract to set whether or not it's trusted for
* executing transfers to/from vaults
* @param _isTrusted True if the token converter is trusted, false otherwise
*/
function ownerSetIsTokenConverterTrusted(address _tokenConverter, bool _isTrusted) external;
// ======================================================
// ================== User Functions ===================
// ======================================================
/**
* @notice Creates the vault for `_account`
*
* @param _account The account owner to create the vault for
*/
function createVault(address _account) external returns (address);
/**
* @notice Creates the vault for `msg.sender`
*
* @param _toAccountNumber The account number of the account to which the tokens will be deposited
* @param _amountWei The amount of tokens to deposit
*/
function createVaultAndDepositIntoDolomiteMargin(
uint256 _toAccountNumber,
uint256 _amountWei
) external returns (address);
/**
* @notice Deposits a token into the vault owner's account at `_toAccountNumber`. This function can only be called
* by a user's vault contract. Reverts if `_marketId` is set to the market ID of this vault.
*
* @param _toAccountNumber The account number of the account to which the tokens will be deposited
* @param _marketId The market ID of the token to deposit
* @param _amountWei The amount of tokens to deposit
*/
function depositOtherTokenIntoDolomiteMarginForVaultOwner(
uint256 _toAccountNumber,
uint256 _marketId,
uint256 _amountWei
)
external;
/**
* @notice Enqueues a transfer into Dolomite Margin from the vault. Assumes msg.sender is a trusted token
* converter, else reverts. Reverts if `_vault` is not a valid vault contract.
*
* @param _vault The address of the vault that the token converter is interacting with
* @param _amountWei The amount of tokens to transfer into Dolomite Margin
*/
function enqueueTransferIntoDolomiteMargin(
address _vault,
uint256 _amountWei
)
external;
/**
* @notice Enqueues a transfer from Dolomite Margin to the token converter. Assumes msg.sender is a trusted token
* converter, else reverts. Reverts if `_vault` is not a valid vault contract.
*
* @param _vault The address of the vault that the token converter is interacting with
* @param _amountWei The amount of tokens to transfer from Dolomite Margin to the token converter
*/
function enqueueTransferFromDolomiteMargin(
address _vault,
uint256 _amountWei
)
external;
/**
* @notice This function should only be called by a user's vault contract
*
* @param _toAccountNumber The account number of the account to which the tokens will be deposited
* @param _amountWei The amount of tokens to deposit
*/
function depositIntoDolomiteMargin(
uint256 _toAccountNumber,
uint256 _amountWei
)
external;
/**
* @notice This function should only be called by a user's vault contract
*
* @param _fromAccountNumber The account number of the account from which the tokens will be withdrawn
* @param _amountWei The amount of tokens to withdraw
*/
function withdrawFromDolomiteMargin(
uint256 _fromAccountNumber,
uint256 _amountWei
)
external;
// ============================================
// ================= Constants ================
// ============================================
/**
* @return The address of the token that this vault wraps around
*/
function UNDERLYING_TOKEN() external view returns (address);
/**
* @return The address of the BorrowPositionProxyV2 contract
*/
function BORROW_POSITION_PROXY() external view returns (IBorrowPositionProxyV2);
// =================================================
// ================= View Functions ================
// =================================================
/**
* @return The market ID of this token contract according to DolomiteMargin. This value is initializes in the
* #initialize function
*/
function marketId() external view returns (uint256);
/**
* @return This function should always return `true`. It's used by The Graph to index this contract as a Wrapper.
*/
function isIsolationAsset() external view returns (bool);
/**
* @return Returns the current transfer cursor
*/
function transferCursor() external view returns (uint256);
/**
*
* @param _transferCursor The cursor used to key into the mapping of queued transfers
* @return The transfer enqueued in the mapping at the cursor's position
*/
function getQueuedTransferByCursor(uint256 _transferCursor) external view returns (QueuedTransfer memory);
/**
* @return The market IDs of the assets that can be borrowed in a position with this wrapped asset. An empty array
* indicates that any non-isolation mode asset can be borrowed against it.
*/
function allowableDebtMarketIds() external view returns (uint256[] memory);
/**
* @return The market IDs of the assets that can be used as collateral in a position with this wrapped asset. An
* empty array indicates that any non-isolation mode asset can be borrowed against it. To indicate that no
* assets can be used as collateral, return an array with a single element containing #marketId().
*/
function allowableCollateralMarketIds() external view returns (uint256[] memory);
/**
* @return The address of the current vault implementation contract
*/
function userVaultImplementation() external view returns (address);
/**
*
* @param _account The account owner to get the vault for
* @return _vault The address of the vault created for `_account`. Returns address(0) if no vault has been
* created yet for this account.
*/
function getVaultByAccount(address _account) external view returns (address _vault);
/**
* @notice Same as `getVaultByAccount`, but always returns the user's non-zero vault address.
*/
function calculateVaultByAccount(address _account) external view returns (address _vault);
/**
*
* @param _vault The vault that's used by an account for depositing/withdrawing
* @return _account The address of the account that owns the `_vault`
*/
function getAccountByVault(address _vault) external view returns (address _account);
/**
* @notice A token converter is used to convert this underlying token into a Dolomite-compatible one for deposit
* or withdrawal
* @return True if the token converter is currently in-use by this contract.
*/
function isTokenConverterTrusted(address _tokenConverter) external view returns (bool);
function getProxyVaultInitCodeHash() external pure returns (bytes32);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteMargin } from "../../protocol/interfaces/IDolomiteMargin.sol";
import { IDolomiteMarginExchangeWrapper } from "../../protocol/interfaces/IDolomiteMarginExchangeWrapper.sol";
/**
* @title IIsolationModeWrapperTraderV2
* @author Dolomite
*
* Interface for a contract that can convert a token into an isolation mode token.
*/
interface IIsolationModeWrapperTraderV2 is IDolomiteMarginExchangeWrapper {
struct CreateActionsForWrappingParams {
/// @dev The index of the account (according the Accounts[] array) that is performing the sell.
uint256 primaryAccountId;
/// @dev The index of the account (according the Accounts[] array) that is being liquidated. This is set to
/// `_primaryAccountId` if a liquidation is not occurring.
uint256 otherAccountId;
/// @dev The address of the owner of the account that is performing the sell.
address primaryAccountOwner;
/// @dev The account number of the owner of the account that is performing the sell.
uint256 primaryAccountNumber;
/// @dev The address of the owner of the account that is being liquidated. This is set to
/// `_primaryAccountOwner` if a liquidation is not occurring.
address otherAccountOwner;
/// @dev The account number of the owner of the account that is being liquidated. This is set to
/// `_primaryAccountNumber` if a liquidation is not occurring.
uint256 otherAccountNumber;
/// @dev The market that is being outputted by the wrapping, should be equal to `token().
uint256 outputMarket;
/// @dev The market that is being used to wrap into `token()`.
uint256 inputMarket;
/// @dev The min amount of `_outputMarket` that must be outputted by the wrapping.
uint256 minOutputAmount;
/// @dev The amount of the `_inputMarket` that the _primaryAccountId must sell.
uint256 inputAmount;
/// @dev The calldata to pass through to any external sales that occur.
bytes orderData;
}
/**
* @return The isolation mode token that this contract can wrap (the output token)
*/
function token() external view returns (address);
/**
* @return True if the `_inputToken` is a valid input token for this contract, to be wrapped into `token()`
*/
function isValidInputToken(address _inputToken) external view returns (bool);
/**
* @notice Creates the necessary actions for selling the `_inputMarket` into `_outputMarket`. Note, the
* `_outputMarket` should be equal to `token()` and `_inputMarket` should be validated to be a correct
* market that can be transformed into `token()`.
*
* @param _params The parameters for creating the actions for wrapping.
* @return The actions that will be executed to unwrap the `_inputMarket` into `_outputMarket`.
*/
function createActionsForWrapping(
CreateActionsForWrappingParams calldata _params
)
external
view
returns (IDolomiteMargin.ActionArgs[] memory);
/**
* @return The number of Actions used to wrap a valid input token into the this wrapper's Isolation Mode token.
*/
function actionsLength() external pure returns (uint256);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IIsolationModeUnwrapperTraderV2 } from "./IIsolationModeUnwrapperTraderV2.sol";
import { IIsolationModeVaultFactory } from "./IIsolationModeVaultFactory.sol";
import { IOnlyDolomiteMargin } from "../../interfaces/IOnlyDolomiteMargin.sol";
/**
* @title IUpgradeableAsyncIsolationModeUnwrapperTrader
* @author Dolomite
*
* Interface for an upgradeable contract that can convert an isolation mode token into another token.
*/
interface IUpgradeableAsyncIsolationModeUnwrapperTrader is IIsolationModeUnwrapperTraderV2, IOnlyDolomiteMargin {
// ================================================
// ==================== Structs ===================
// ================================================
struct WithdrawalInfo {
bytes32 key;
address vault;
uint256 accountNumber;
/// @dev The amount of FACTORY tokens that is being sold
uint256 inputAmount;
address outputToken;
/// @dev initially 0 until the withdrawal is executed
uint256 outputAmount;
bool isRetryable;
bool isLiquidation;
bytes extraData;
}
struct State {
uint256 actionsLength;
uint256 reentrancyGuard;
address vaultFactory;
address handlerRegistry;
mapping(bytes32 => WithdrawalInfo) withdrawalInfo;
}
// ================================================
// ===================== Enums ====================
// ================================================
enum TradeType {
FromWithdrawal,
FromDeposit,
NoOp
}
// ===================================================
// ==================== Functions ====================
// ===================================================
/**
* Notifies the unwrapper that it'll be entered for a trade from the unwrapper. This allows it to modify the action
* length
*/
function handleCallbackFromWrapperBefore() external;
/**
* Reverts any changes made in `handleCallbackFromWrapperBefore`. Can only be called by a corresponding Wrapper
* trader.
*/
function handleCallbackFromWrapperAfter() external;
/**
* Transfers underlying tokens from the vault (msg.sender) to this contract to initiate a redemption.
*/
function vaultInitiateUnwrapping(
uint256 _tradeAccountNumber,
uint256 _inputAmount,
address _outputToken,
uint256 _minOutputAmount,
bool _isLiquidation,
bytes calldata _extraData
) external payable;
/**
*
* @param _key The key of the withdrawal that should be cancelled
*/
function initiateCancelWithdrawal(bytes32 _key) external;
function getWithdrawalInfo(bytes32 _key) external view returns (WithdrawalInfo memory);
function VAULT_FACTORY() external view returns (IIsolationModeVaultFactory);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IIsolationModeVaultFactory } from "./IIsolationModeVaultFactory.sol";
import { IIsolationModeWrapperTraderV2 } from "./IIsolationModeWrapperTraderV2.sol";
import { IOnlyDolomiteMargin } from "../../interfaces/IOnlyDolomiteMargin.sol";
/**
* @title IUpgradeableAsyncIsolationModeWrapperTrader
* @author Dolomite
*
* Interface for an upgradeable contract that can convert a token into an isolation mode token.
*/
interface IUpgradeableAsyncIsolationModeWrapperTrader is IIsolationModeWrapperTraderV2, IOnlyDolomiteMargin {
// ================================================
// ==================== Structs ===================
// ================================================
struct State {
mapping(bytes32 => DepositInfo) depositInfo;
address vaultFactory;
address handlerRegistry;
}
struct DepositInfo {
bytes32 key;
address vault;
uint256 accountNumber;
address inputToken;
uint256 inputAmount;
uint256 outputAmount;
bool isRetryable;
}
// ===================================================
// ==================== Functions ====================
// ===================================================
/**
* This should be called by the vault to initiate a cancellation for a deposit.
*
* @param _key The key of the deposit that should be cancelled
*/
function initiateCancelDeposit(bytes32 _key) external;
function setDepositInfoAndReducePendingAmountFromUnwrapper(
bytes32 _key,
uint256 _outputAmountDeltaWei,
DepositInfo calldata _depositInfo
) external;
function getDepositInfo(bytes32 _key) external view returns (DepositInfo memory);
function VAULT_FACTORY() external view returns (IIsolationModeVaultFactory);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteMargin } from "../protocol/interfaces/IDolomiteMargin.sol";
import { IDolomiteStructs } from "../protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "../protocol/lib/Require.sol";
import { TypesLib } from "../protocol/lib/TypesLib.sol";
/**
* @title AccountBalanceLib
* @author Dolomite
*
* @notice Library contract that checks a user's balance after transaction to be non-negative
*/
library AccountBalanceLib {
using TypesLib for IDolomiteStructs.Par;
// ============ Types ============
/// Checks that either BOTH, FROM, or TO accounts all have non-negative balances
enum BalanceCheckFlag {
Both,
From,
To,
None
}
// ============ Constants ============
bytes32 private constant _FILE = "AccountBalanceLib";
// ============ Functions ============
/**
* Checks that the account's balance is non-negative. Reverts if the check fails
*/
function verifyBalanceIsNonNegative(
IDolomiteMargin dolomiteMargin,
address _accountOwner,
uint256 _accountNumber,
uint256 _marketId
) internal view {
IDolomiteStructs.AccountInfo memory account = IDolomiteStructs.AccountInfo({
owner: _accountOwner,
number: _accountNumber
});
IDolomiteStructs.Par memory par = dolomiteMargin.getAccountPar(account, _marketId);
Require.that(
par.isPositive() || par.isZero(),
_FILE,
"account cannot go negative",
_accountOwner,
_accountNumber,
_marketId
);
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IDolomiteStructs } from "./IDolomiteStructs.sol";
/**
* @title IDolomiteAccountRiskOverrideSetter
* @author Dolomite
*
* @notice Interface that can be implemented by any contract that needs to implement risk overrides for an account.
*/
interface IDolomiteAccountRiskOverrideSetter {
/**
* @notice Gets the risk overrides for a given account owner.
*
* @param _accountOwner The owner of the account whose risk override should be retrieved.
* @return marginRatioOverride The margin ratio override for this account.
* @return liquidationSpreadOverride The liquidation spread override for this account.
*/
function getAccountRiskOverride(
address _accountOwner
)
external
view
returns
(
IDolomiteStructs.Decimal memory marginRatioOverride,
IDolomiteStructs.Decimal memory liquidationSpreadOverride
);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
/**
* @title IDolomiteInterestSetter
* @author Dolomite
*
* @notice This interface defines the functions that for an interest setter that can be used to determine the interest
* rate of a market.
*/
interface IDolomiteInterestSetter {
// ============ Enum ============
enum InterestSetterType {
None,
Linear,
DoubleExponential,
Other
}
// ============ Structs ============
struct InterestRate {
uint256 value;
}
// ============ Functions ============
/**
* Get the interest rate of a token given some borrowed and supplied amounts
*
* @param token The address of the ERC20 token for the market
* @param borrowWei The total borrowed token amount for the market
* @param supplyWei The total supplied token amount for the market
* @return The interest rate per second
*/
function getInterestRate(
address token,
uint256 borrowWei,
uint256 supplyWei
)
external
view
returns (InterestRate memory);
function interestSetterType() external pure returns (InterestSetterType);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteInterestSetter } from "./IDolomiteInterestSetter.sol";
import { IDolomiteMarginAdmin } from "./IDolomiteMarginAdmin.sol";
import { IDolomitePriceOracle } from "./IDolomitePriceOracle.sol";
/**
* @title IDolomiteMargin
* @author Dolomite
*
* @notice The interface for interacting with the main entry-point to DolomiteMargin
*/
interface IDolomiteMargin is IDolomiteMarginAdmin {
// ==================================================
// ================= Write Functions ================
// ==================================================
/**
* The main entry-point to DolomiteMargin that allows users and contracts to manage accounts.
* Take one or more actions on one or more accounts. The msg.sender must be the owner or
* operator of all accounts except for those being liquidated, vaporized, or traded with.
* One call to operate() is considered a singular "operation". Account collateralization is
* ensured only after the completion of the entire operation.
*
* @param accounts A list of all accounts that will be used in this operation. Cannot contain
* duplicates. In each action, the relevant account will be referred-to by its
* index in the list.
* @param actions An ordered list of all actions that will be taken in this operation. The
* actions will be processed in order.
*/
function operate(
AccountInfo[] calldata accounts,
ActionArgs[] calldata actions
) external;
/**
* Approves/disapproves any number of operators. An operator is an external address that has the
* same permissions to manipulate an account as the owner of the account. Operators are simply
* addresses and therefore may either be externally-owned Ethereum accounts OR smart contracts.
*
* Operators are also able to act as AutoTrader contracts on behalf of the account owner if the
* operator is a smart contract and implements the IAutoTrader interface.
*
* @param args A list of OperatorArgs which have an address and a boolean. The boolean value
* denotes whether to approve (true) or revoke approval (false) for that address.
*/
function setOperators(
OperatorArg[] calldata args
) external;
// ==================================================
// ================= Read Functions ================
// ==================================================
// ============ Getters for Markets ============
/**
* Get the ERC20 token address for a market.
*
* @param token The token to query
* @return The token's marketId if the token is valid
*/
function getMarketIdByTokenAddress(
address token
) external view returns (uint256);
/**
* Get the ERC20 token address for a market.
*
* @param marketId The market to query
* @return The token address
*/
function getMarketTokenAddress(
uint256 marketId
) external view returns (address);
/**
* Return the maximum amount of the market that can be supplied on Dolomite. Always 0 or positive.
*
* @param marketId The market to query
* @return The max amount of the market that can be supplied
*/
function getMarketMaxWei(
uint256 marketId
) external view returns (Wei memory);
/**
* Return true if a particular market is in closing mode. Additional borrows cannot be taken
* from a market that is closing.
*
* @param marketId The market to query
* @return True if the market is closing
*/
function getMarketIsClosing(
uint256 marketId
)
external
view
returns (bool);
/**
* Get the price of the token for a market.
*
* @param marketId The market to query
* @return The price of each atomic unit of the token
*/
function getMarketPrice(
uint256 marketId
) external view returns (MonetaryPrice memory);
/**
* Get the total number of markets.
*
* @return The number of markets
*/
function getNumMarkets() external view returns (uint256);
/**
* Get the total principal amounts (borrowed and supplied) for a market.
*
* @param marketId The market to query
* @return The total principal amounts
*/
function getMarketTotalPar(
uint256 marketId
) external view returns (TotalPar memory);
/**
* Get the most recently cached interest index for a market.
*
* @param marketId The market to query
* @return The most recent index
*/
function getMarketCachedIndex(
uint256 marketId
) external view returns (InterestIndex memory);
/**
* Get the interest index for a market if it were to be updated right now.
*
* @param marketId The market to query
* @return The estimated current index
*/
function getMarketCurrentIndex(
uint256 marketId
) external view returns (InterestIndex memory);
/**
* Get the price oracle address for a market.
*
* @param marketId The market to query
* @return The price oracle address
*/
function getMarketPriceOracle(
uint256 marketId
) external view returns (IDolomitePriceOracle);
/**
* Get the interest-setter address for a market.
*
* @param marketId The market to query
* @return The interest-setter address
*/
function getMarketInterestSetter(
uint256 marketId
) external view returns (IDolomiteInterestSetter);
/**
* Get the margin premium for a market. A margin premium makes it so that any positions that
* include the market require a higher collateralization to avoid being liquidated.
*
* @param marketId The market to query
* @return The market's margin premium
*/
function getMarketMarginPremium(
uint256 marketId
) external view returns (Decimal memory);
/**
* Get the spread premium for a market. A spread premium makes it so that any liquidations
* that include the market have a higher spread than the global default.
*
* @param marketId The market to query
* @return The market's spread premium
*/
function getMarketSpreadPremium(
uint256 marketId
) external view returns (Decimal memory);
/**
* Return true if this market can be removed and its ID can be recycled and reused
*
* @param marketId The market to query
* @return True if the market is recyclable
*/
function getMarketIsRecyclable(
uint256 marketId
) external view returns (bool);
/**
* Gets the recyclable markets, up to `n` length. If `n` is greater than the length of the list, 0's are returned
* for the empty slots.
*
* @param n The number of markets to get, bounded by the linked list being smaller than `n`
* @return The list of recyclable markets, in the same order held by the linked list
*/
function getRecyclableMarkets(
uint256 n
) external view returns (uint[] memory);
/**
* Get the current borrower interest rate for a market.
*
* @param marketId The market to query
* @return The current interest rate
*/
function getMarketInterestRate(
uint256 marketId
) external view returns (IDolomiteInterestSetter.InterestRate memory);
/**
* Get basic information about a particular market.
*
* @param marketId The market to query
* @return A Market struct with the current state of the market
*/
function getMarket(
uint256 marketId
) external view returns (Market memory);
/**
* Get comprehensive information about a particular market.
*
* @param marketId The market to query
* @return A tuple containing the values:
* - A Market struct with the current state of the market
* - The current estimated interest index
* - The current token price
* - The current market interest rate
*/
function getMarketWithInfo(
uint256 marketId
)
external
view
returns (
Market memory,
InterestIndex memory,
MonetaryPrice memory,
IDolomiteInterestSetter.InterestRate memory
);
/**
* Get the number of excess tokens for a market. The number of excess tokens is calculated by taking the current
* number of tokens held in DolomiteMargin, adding the number of tokens owed to DolomiteMargin by borrowers, and
* subtracting the number of tokens owed to suppliers by DolomiteMargin.
*
* @param marketId The market to query
* @return The number of excess tokens
*/
function getNumExcessTokens(
uint256 marketId
) external view returns (Wei memory);
// ============ Getters for Accounts ============
/**
* Get the principal value for a particular account and market.
*
* @param account The account to query
* @param marketId The market to query
* @return The principal value
*/
function getAccountPar(
AccountInfo calldata account,
uint256 marketId
) external view returns (Par memory);
/**
* Get the principal value for a particular account and market, with no check the market is valid. Meaning, markets
* that don't exist return 0.
*
* @param account The account to query
* @param marketId The market to query
* @return The principal value
*/
function getAccountParNoMarketCheck(
AccountInfo calldata account,
uint256 marketId
) external view returns (Par memory);
/**
* Get the token balance for a particular account and market.
*
* @param account The account to query
* @param marketId The market to query
* @return The token amount
*/
function getAccountWei(
AccountInfo calldata account,
uint256 marketId
) external view returns (Wei memory);
/**
* Get the status of an account (Normal, Liquidating, or Vaporizing).
*
* @param account The account to query
* @return The account's status
*/
function getAccountStatus(
AccountInfo calldata account
) external view returns (AccountStatus);
/**
* Get a list of markets that have a non-zero balance for an account
*
* @param account The account to query
* @return The non-sorted marketIds with non-zero balance for the account.
*/
function getAccountMarketsWithBalances(
AccountInfo calldata account
) external view returns (uint256[] memory);
/**
* Get the number of markets that have a non-zero balance for an account
*
* @param account The account to query
* @return The non-sorted marketIds with non-zero balance for the account.
*/
function getAccountNumberOfMarketsWithBalances(
AccountInfo calldata account
) external view returns (uint256);
/**
* Get the marketId for an account's market with a non-zero balance at the given index
*
* @param account The account to query
* @return The non-sorted marketIds with non-zero balance for the account.
*/
function getAccountMarketWithBalanceAtIndex(
AccountInfo calldata account,
uint256 index
) external view returns (uint256);
/**
* Get the number of markets with which an account has a negative balance.
*
* @param account The account to query
* @return The non-sorted marketIds with non-zero balance for the account.
*/
function getAccountNumberOfMarketsWithDebt(
AccountInfo calldata account
) external view returns (uint256);
/**
* Get the total supplied and total borrowed value of an account.
*
* @param account The account to query
* @return The following values:
* - The supplied value of the account
* - The borrowed value of the account
*/
function getAccountValues(
AccountInfo calldata account
) external view returns (MonetaryValue memory, MonetaryValue memory);
/**
* Get the total supplied and total borrowed values of an account adjusted by the marginPremium
* of each market. Supplied values are divided by (1 + marginPremium) for each market and
* borrowed values are multiplied by (1 + marginPremium) for each market. Comparing these
* adjusted values gives the margin-ratio of the account which will be compared to the global
* margin-ratio when determining if the account can be liquidated.
*
* @param account The account to query
* @return The following values:
* - The supplied value of the account (adjusted for marginPremium)
* - The borrowed value of the account (adjusted for marginPremium)
*/
function getAdjustedAccountValues(
AccountInfo calldata account
) external view returns (MonetaryValue memory, MonetaryValue memory);
/**
* Get an account's summary for each market.
*
* @param account The account to query
* @return The following values:
* - The market IDs for each market
* - The ERC20 token address for each market
* - The account's principal value for each market
* - The account's (supplied or borrowed) number of tokens for each market
*/
function getAccountBalances(
AccountInfo calldata account
) external view returns (uint[] memory, address[] memory, Par[] memory, Wei[] memory);
// ============ Getters for Account Permissions ============
/**
* Return true if a particular address is approved as an operator for an owner's accounts.
* Approved operators can act on the accounts of the owner as if it were the operator's own.
*
* @param owner The owner of the accounts
* @param operator The possible operator
* @return True if operator is approved for owner's accounts
*/
function getIsLocalOperator(
address owner,
address operator
) external view returns (bool);
/**
* Return true if a particular address is approved as a global operator. Such an address can
* act on any account as if it were the operator's own.
*
* @param operator The address to query
* @return True if operator is a global operator
*/
function getIsGlobalOperator(
address operator
) external view returns (bool);
/**
* Checks if the autoTrader can only be called invoked by a global operator
*
* @param autoTrader The trader that should be checked for special call privileges.
*/
function getIsAutoTraderSpecial(address autoTrader) external view returns (bool);
/**
* @return The address that owns the DolomiteMargin protocol
*/
function owner() external view returns (address);
// ============ Getters for Risk Params ============
/**
* Get the global minimum margin-ratio that every position must maintain to prevent being
* liquidated.
*
* @return The global margin-ratio
*/
function getMarginRatio() external view returns (Decimal memory);
/**
* Get the global liquidation spread. This is the spread between oracle prices that incentivizes
* the liquidation of risky positions.
*
* @return The global liquidation spread
*/
function getLiquidationSpread() external view returns (Decimal memory);
/**
* Get the adjusted liquidation spread for some market pair. This is equal to the global
* liquidation spread multiplied by (1 + spreadPremium) for each of the two markets.
*
* @param heldMarketId The market for which the account has collateral
* @param owedMarketId The market for which the account has borrowed tokens
* @return The adjusted liquidation spread
*/
function getLiquidationSpreadForPair(
uint256 heldMarketId,
uint256 owedMarketId
) external view returns (Decimal memory);
/**
* Get the global earnings-rate variable that determines what percentage of the interest paid
* by borrowers gets passed-on to suppliers.
*
* @return The global earnings rate
*/
function getEarningsRate() external view returns (Decimal memory);
/**
* Get the global minimum-borrow value which is the minimum value of any new borrow on DolomiteMargin.
*
* @return The global minimum borrow value
*/
function getMinBorrowedValue() external view returns (MonetaryValue memory);
/**
* Get all risk parameters in a single struct.
*
* @return All global risk parameters
*/
function getRiskParams() external view returns (RiskParams memory);
/**
* Get all risk parameter limits in a single struct. These are the maximum limits at which the
* risk parameters can be set by the admin of DolomiteMargin.
*
* @return All global risk parameter limits
*/
function getRiskLimits() external view returns (RiskLimits memory);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteInterestSetter } from "./IDolomiteInterestSetter.sol";
import { IDolomitePriceOracle } from "./IDolomitePriceOracle.sol";
import { IDolomiteStructs } from "./IDolomiteStructs.sol";
/**
* @title IDolomiteMarginAdmin
* @author Dolomite
*
* @notice This interface defines the functions that can be called by the owner of DolomiteMargin.
*/
interface IDolomiteMarginAdmin is IDolomiteStructs {
// ============ Token Functions ============
/**
* Withdraw an ERC20 token for which there is an associated market. Only excess tokens can be withdrawn. The number
* of excess tokens is calculated by taking the current number of tokens held in DolomiteMargin, adding the number
* of tokens owed to DolomiteMargin by borrowers, and subtracting the number of tokens owed to suppliers by
* DolomiteMargin.
*/
function ownerWithdrawExcessTokens(
uint256 marketId,
address recipient
)
external
returns (uint256);
/**
* Withdraw an ERC20 token for which there is no associated market.
*/
function ownerWithdrawUnsupportedTokens(
address token,
address recipient
)
external
returns (uint256);
// ============ Market Functions ============
/**
* Sets the number of non-zero balances an account may have within the same `accountIndex`. This ensures a user
* cannot DOS the system by filling their account with non-zero balances (which linearly increases gas costs when
* checking collateralization) and disallowing themselves to close the position, because the number of gas units
* needed to process their transaction exceed the block's gas limit. In turn, this would prevent the user from also
* being liquidated, causing the all of the capital to be "stuck" in the position.
*
* Lowering this number does not "freeze" user accounts that have more than the new limit of balances, because this
* variable is enforced by checking the users number of non-zero balances against the max or if it sizes down before
* each transaction finishes.
*/
function ownerSetAccountMaxNumberOfMarketsWithBalances(
uint256 accountMaxNumberOfMarketsWithBalances
)
external;
/**
* Add a new market to DolomiteMargin. Must be for a previously-unsupported ERC20 token.
*/
function ownerAddMarket(
address token,
IDolomitePriceOracle priceOracle,
IDolomiteInterestSetter interestSetter,
Decimal calldata marginPremium,
Decimal calldata spreadPremium,
uint256 maxWei,
bool isClosing,
bool isRecyclable
)
external;
/**
* Removes a market from DolomiteMargin, sends any remaining tokens in this contract to `salvager` and invokes the
* recyclable callback
*/
function ownerRemoveMarkets(
uint[] calldata marketIds,
address salvager
)
external;
/**
* Set (or unset) the status of a market to "closing". The borrowedValue of a market cannot increase while its
* status is "closing".
*/
function ownerSetIsClosing(
uint256 marketId,
bool isClosing
)
external;
/**
* Set the price oracle for a market.
*/
function ownerSetPriceOracle(
uint256 marketId,
IDolomitePriceOracle priceOracle
)
external;
/**
* Set the interest-setter for a market.
*/
function ownerSetInterestSetter(
uint256 marketId,
IDolomiteInterestSetter interestSetter
)
external;
/**
* Set a premium on the minimum margin-ratio for a market. This makes it so that any positions that include this
* market require a higher collateralization to avoid being liquidated.
*/
function ownerSetMarginPremium(
uint256 marketId,
Decimal calldata marginPremium
)
external;
function ownerSetMaxWei(
uint256 marketId,
uint256 maxWei
)
external;
/**
* Set a premium on the liquidation spread for a market. This makes it so that any liquidations that include this
* market have a higher spread than the global default.
*/
function ownerSetSpreadPremium(
uint256 marketId,
Decimal calldata spreadPremium
)
external;
// ============ Risk Functions ============
/**
* Set the global minimum margin-ratio that every position must maintain to prevent being liquidated.
*/
function ownerSetMarginRatio(
Decimal calldata ratio
)
external;
/**
* Set the global liquidation spread. This is the spread between oracle prices that incentivizes the liquidation of
* risky positions.
*/
function ownerSetLiquidationSpread(
Decimal calldata spread
)
external;
/**
* Set the global earnings-rate variable that determines what percentage of the interest paid by borrowers gets
* passed-on to suppliers.
*/
function ownerSetEarningsRate(
Decimal calldata earningsRate
)
external;
/**
* Set the global minimum-borrow value which is the minimum value of any new borrow on DolomiteMargin.
*/
function ownerSetMinBorrowedValue(
MonetaryValue calldata minBorrowedValue
)
external;
// ============ Global Operator Functions ============
/**
* Approve (or disapprove) an address that is permissioned to be an operator for all accounts in DolomiteMargin.
* Intended only to approve smart-contracts.
*/
function ownerSetGlobalOperator(
address operator,
bool approved
)
external;
/**
* Approve (or disapprove) an auto trader that can only be called by a global operator. IE for expirations
*/
function ownerSetAutoTraderSpecial(
address autoTrader,
bool special
)
external;
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2019 dYdX Trading Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
/**
* @title IDolomiteMarginExchangeWrapper
* @author dYdX
*
* @notice Interface that Exchange Wrappers for DolomiteMargin must implement in order to trade ERC20 tokens with
* external protocols.
*/
interface IDolomiteMarginExchangeWrapper {
// ============ Public Functions ============
/**
* Exchange some amount of inputToken for outputToken.
*
* @param _tradeOriginator Address of the initiator of the trade (however, this value cannot always be trusted as
* it is set at the discretion of the msg.sender)
* @param _receiver Address to set allowance on once the trade has completed
* @param _outputToken The token to receive (target asset; IE path[path.length - 1])
* @param _inputToken The token to pay (originator asset; IE path[0])
* @param _inputAmount Amount of `inputToken` being paid to this wrapper
* @param _orderData Arbitrary bytes data for any information to pass to the exchange
* @return The amount of outputToken to be received by DolomiteMargin
*/
function exchange(
address _tradeOriginator,
address _receiver,
address _outputToken,
address _inputToken,
uint256 _inputAmount,
bytes calldata _orderData
)
external
returns (uint256);
/**
* Get amount of `inputToken` required to buy a certain amount of `outputToken` for a given trade.
* Should match the `inputToken` amount used in exchangeForAmount. If the order cannot provide
* exactly `_desiredOutputToken`, then it must return the price to buy the minimum amount greater
* than `_desiredOutputToken`
*
* @param _inputToken The token to pay to this contract (originator asset; IE path[0])
* @param _outputToken The token to receive by DolomiteMargin (target asset; IE path[path.length - 1])
* @param _desiredInputAmount Amount of `_inputToken` requested
* @param _orderData Arbitrary bytes data for any information to pass to the exchange
* @return Amount of `_inputToken` the needed to complete the exchange
*/
function getExchangeCost(
address _inputToken,
address _outputToken,
uint256 _desiredInputAmount,
bytes calldata _orderData
)
external
view
returns (uint256);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
/**
* @title IDolomiteOracleSentinel
* @author Dolomite
*
* Interface that Dolomite pings to check if the Blockchain or L2 is alive, if liquidations should be processed, and if
* markets should are in size-down only mode.
*/
interface IDolomiteOracleSentinel {
// ============ Events ============
event GracePeriodSet(
uint256 gracePeriod
);
// ============ Functions ============
/**
* @dev Allows the owner to set the grace period duration, which specifies how long the system will disallow
* liquidations after sequencer is back online. Only callable by the owner.
*
* @param _gracePeriod The new duration of the grace period
*/
function ownerSetGracePeriod(
uint256 _gracePeriod
)
external;
/**
* @return True if new borrows should be allowed, false otherwise
*/
function isBorrowAllowed() external view returns (bool);
/**
* @return True if liquidations should be allowed, false otherwise
*/
function isLiquidationAllowed() external view returns (bool);
/**
* @return The duration between when the feed comes back online and when the system will allow liquidations to be
* processed normally
*/
function gracePeriod() external view returns (uint256);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteStructs } from "./IDolomiteStructs.sol";
/**
* @title IDolomitePriceOracle
* @author Dolomite
*
* @notice Interface that Price Oracles for DolomiteMargin must implement in order to report prices.
*/
interface IDolomitePriceOracle {
// ============ Public Functions ============
/**
* Get the price of a token
*
* @param token The ERC20 token address of the market
* @return The USD price of a base unit of the token, then multiplied by 10^(36 - decimals).
* So a USD-stable coin with 6 decimal places would return `price * 10^30`.
* This is the price of the base unit rather than the price of a "human-readable"
* token amount. Every ERC20 may have a different number of decimals.
*/
function getPrice(
address token
)
external
view
returns (IDolomiteStructs.MonetaryPrice memory);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteAccountRiskOverrideSetter } from "./IDolomiteAccountRiskOverrideSetter.sol";
import { IDolomiteInterestSetter } from "./IDolomiteInterestSetter.sol";
import { IDolomiteOracleSentinel } from "./IDolomiteOracleSentinel.sol";
import { IDolomitePriceOracle } from "./IDolomitePriceOracle.sol";
/**
* @title IDolomiteStructs
* @author Dolomite
*
* @notice This interface defines the structs used by DolomiteMargin
*/
interface IDolomiteStructs {
// ========================= Enums =========================
enum ActionType {
Deposit, // supply tokens
Withdraw, // borrow tokens
Transfer, // transfer balance between accounts
Buy, // buy an amount of some token (externally)
Sell, // sell an amount of some token (externally)
Trade, // trade tokens against another account
Liquidate, // liquidate an undercollateralized or expiring account
Vaporize, // use excess tokens to zero-out a completely negative account
Call // send arbitrary data to an address
}
enum AssetDenomination {
Wei, // the amount is denominated in wei
Par // the amount is denominated in par
}
enum AssetReference {
Delta, // the amount is given as a delta from the current value
Target // the amount is given as an exact number to end up at
}
// ========================= Structs =========================
struct AccountInfo {
address owner; // The address that owns the account
uint256 number; // A nonce that allows a single address to control many accounts
}
/**
* Most-recently-cached account status.
*
* Normal: Can only be liquidated if the account values are violating the global margin-ratio.
* Liquid: Can be liquidated no matter the account values.
* Can be vaporized if there are no more positive account values.
* Vapor: Has only negative (or zeroed) account values. Can be vaporized.
*
*/
enum AccountStatus {
Normal,
Liquid,
Vapor
}
/*
* Arguments that are passed to DolomiteMargin in an ordered list as part of a single operation.
* Each ActionArgs has an actionType which specifies which action struct that this data will be
* parsed into before being processed.
*/
struct ActionArgs {
ActionType actionType;
uint256 accountId;
AssetAmount amount;
uint256 primaryMarketId;
uint256 secondaryMarketId;
address otherAddress;
uint256 otherAccountId;
bytes data;
}
struct AssetAmount {
bool sign; // true if positive
AssetDenomination denomination;
AssetReference ref;
uint256 value;
}
struct Decimal {
uint256 value;
}
struct InterestIndex {
uint96 borrow;
uint96 supply;
uint32 lastUpdate;
}
struct Market {
address token;
// Whether additional borrows are allowed for this market
bool isClosing;
// Whether this market can be removed and its ID can be recycled and reused
bool isRecyclable;
// Total aggregated supply and borrow amount of the entire market
TotalPar totalPar;
// Interest index of the market
InterestIndex index;
// Contract address of the price oracle for this market
IDolomitePriceOracle priceOracle;
// Contract address of the interest setter for this market
IDolomiteInterestSetter interestSetter;
// Multiplier on the marginRatio for this market, IE 5% (0.05 * 1e18). This number increases the market's
// required collateralization by: reducing the user's supplied value (in terms of dollars) for this market and
// increasing its borrowed value. This is done through the following operation:
// `suppliedWei = suppliedWei + (assetValueForThisMarket / (1 + marginPremium))`
// This number increases the user's borrowed wei by multiplying it by:
// `borrowedWei = borrowedWei + (assetValueForThisMarket * (1 + marginPremium))`
Decimal marginPremium;
// Multiplier on the liquidationSpread for this market, IE 20% (0.2 * 1e18). This number increases the
// `liquidationSpread` using the following formula:
// `liquidationSpread = liquidationSpread * (1 + spreadPremium)`
// NOTE: This formula is applied up to two times - one for each market whose spreadPremium is greater than 0
// (when performing a liquidation between two markets)
Decimal spreadPremium;
// The maximum amount that can be held by the external. This allows the external to cap any additional risk
// that is inferred by allowing borrowing against low-cap or assets with increased volatility. Setting this
// value to 0 is analogous to having no limit. This value can never be below 0.
Wei maxWei;
}
struct MarketV2 {
// Contract address of the associated ERC20 token
address token;
// Whether additional borrows are allowed for this market
bool isClosing;
// Total aggregated supply and borrow amount of the entire market
TotalPar totalPar;
// Interest index of the market
InterestIndex index;
// Contract address of the price oracle for this market
IDolomitePriceOracle priceOracle;
// Contract address of the interest setter for this market
IDolomiteInterestSetter interestSetter;
// Multiplier on the marginRatio for this market, IE 5% (0.05 * 1e18). This number increases the market's
// required collateralization by: reducing the user's supplied value (in terms of dollars) for this market and
// increasing its borrowed value. This is done through the following operation:
// `suppliedWei = suppliedWei + (assetValueForThisMarket / (1 + marginPremium))`
// This number increases the user's borrowed wei by multiplying it by:
// `borrowedWei = borrowedWei + (assetValueForThisMarket * (1 + marginPremium))`
Decimal marginPremium;
// Multiplier on the liquidationSpread for this market, IE 20% (0.2 * 1e18). This number increases the
// `liquidationSpread` using the following formula:
// `liquidationSpread = liquidationSpread * (1 + spreadPremium)`
// NOTE: This formula is applied up to two times - one for each market whose spreadPremium is greater than 0
// (when performing a liquidation between two markets)
Decimal liquidationSpreadPremium;
// The maximum amount that can be held by the protocol. This allows the protocol to cap any additional risk
// that is inferred by allowing borrowing against low-cap or assets with increased volatility. Setting this
// value to 0 is analogous to having no limit. This value can never be below 0.
Wei maxSupplyWei;
// The maximum amount that can be borrowed by the protocol. This allows the protocol to cap any additional risk
// that is inferred by allowing borrowing against low-cap or assets with increased volatility. Setting this
// value to 0 is analogous to having no limit. This value can never be greater than 0.
Wei maxBorrowWei;
// The percentage of interest paid that is passed along from borrowers to suppliers. Setting this to 0 will
// default to RiskParams.earningsRate.
Decimal earningsRateOverride;
}
/*
* The price of a base-unit of an asset. Has `36 - token.decimals` decimals
*/
struct MonetaryPrice {
uint256 value;
}
struct MonetaryValue {
uint256 value;
}
struct OperatorArg {
address operator;
bool trusted;
}
struct Par {
bool sign;
uint128 value;
}
struct RiskLimits {
// The highest that the ratio can be for liquidating under-water accounts
uint64 marginRatioMax;
// The highest that the liquidation rewards can be when a liquidator liquidates an account
uint64 liquidationSpreadMax;
// The highest that the supply APR can be for a market, as a proportion of the borrow rate. Meaning, a rate of
// 100% (1e18) would give suppliers all of the interest that borrowers are paying. A rate of 90% would give
// suppliers 90% of the interest that borrowers pay.
uint64 earningsRateMax;
// The highest min margin ratio premium that can be applied to a particular market. Meaning, a value of 100%
// (1e18) would require borrowers to maintain an extra 100% collateral to maintain a healthy margin ratio. This
// value works by increasing the debt owed and decreasing the supply held for the particular market by this
// amount, plus 1e18 (since a value of 10% needs to be applied as `decimal.plusOne`)
uint64 marginPremiumMax;
// The highest liquidation reward that can be applied to a particular market. This percentage is applied
// in addition to the liquidation spread in `RiskParams`. Meaning a value of 1e18 is 100%. It is calculated as:
// `liquidationSpread * Decimal.onePlus(spreadPremium)`
uint64 spreadPremiumMax;
uint128 minBorrowedValueMax;
}
struct RiskLimitsV2 {
// The highest that the ratio can be for liquidating under-water accounts
uint64 marginRatioMax;
// The highest that the liquidation rewards can be when a liquidator liquidates an account
uint64 liquidationSpreadMax;
// The highest that the supply APR can be for a market, as a proportion of the borrow rate. Meaning, a rate of
// 100% (1e18) would give suppliers all of the interest that borrowers are paying. A rate of 90% would give
// suppliers 90% of the interest that borrowers pay.
uint64 earningsRateMax;
// The highest min margin ratio premium that can be applied to a particular market. Meaning, a value of 100%
// (1e18) would require borrowers to maintain an extra 100% collateral to maintain a healthy margin ratio. This
// value works by increasing the debt owed and decreasing the supply held for the particular market by this
// amount, plus 1e18 (since a value of 10% needs to be applied as `decimal.plusOne`)
uint64 marginPremiumMax;
// The highest liquidation reward that can be applied to a particular market. This percentage is applied
// in addition to the liquidation spread in `RiskParams`. Meaning a value of 1e18 is 100%. It is calculated as:
// `liquidationSpread * Decimal.onePlus(spreadPremium)`
uint64 liquidationSpreadPremiumMax;
// The highest that the borrow interest rate can ever be. If the rate returned is ever higher, the rate is
// capped at this value instead of reverting. The goal is to keep Dolomite operational under all circumstances
// instead of inadvertently DOS'ing the protocol.
uint96 interestRateMax;
// The highest that the minBorrowedValue can be. This is the minimum amount of value that must be borrowed.
// Typically a value of $100 (100 * 1e18) is more than sufficient.
uint128 minBorrowedValueMax;
}
struct RiskParams {
// Required ratio of over-collateralization
Decimal marginRatio;
// Percentage penalty incurred by liquidated accounts
Decimal liquidationSpread;
// Percentage of the borrower's interest fee that gets passed to the suppliers
Decimal earningsRate;
// The minimum absolute borrow value of an account
// There must be sufficient incentivize to liquidate undercollateralized accounts
MonetaryValue minBorrowedValue;
// The maximum number of markets a user can have a non-zero balance for a given account.
uint256 accountMaxNumberOfMarketsWithBalances;
}
// The global risk parameters that govern the health and security of the system
struct RiskParamsV2 {
// Required ratio of over-collateralization
Decimal marginRatio;
// Percentage penalty incurred by liquidated accounts
Decimal liquidationSpread;
// Percentage of the borrower's interest fee that gets passed to the suppliers
Decimal earningsRate;
// The minimum absolute borrow value of an account
// There must be sufficient incentivize to liquidate undercollateralized accounts
MonetaryValue minBorrowedValue;
// The maximum number of markets a user can have a non-zero balance for a given account.
uint256 accountMaxNumberOfMarketsWithBalances;
// The oracle sentinel used to disable borrowing/liquidations if the sequencer goes down
IDolomiteOracleSentinel oracleSentinel;
// The gas limit used for making callbacks via `IExternalCallback::onInternalBalanceChange` to smart contract
// wallets. Setting to 0 will effectively disable callbacks; setting it super large is not desired since it
// could lead to DOS attacks on the protocol; however, hard coding a max value isn't preferred since some chains
// can calculate gas usage differently (like ArbGas before Arbitrum rolled out nitro)
uint256 callbackGasLimit;
// Certain addresses are allowed to borrow with different LTV requirements. When an account's risk is overrode,
// the global risk parameters are ignored and the account's risk parameters are used instead.
mapping(address => IDolomiteAccountRiskOverrideSetter) accountRiskOverrideSetterMap;
}
struct TotalPar {
uint128 borrow;
uint128 supply;
}
struct TotalWei {
uint128 borrow;
uint128 supply;
}
struct Wei {
bool sign;
uint256 value;
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { Require } from "./Require.sol";
/**
* @title DolomiteMarginMath
* @author dYdX
*
* @notice Library for non-standard Math functions
*/
library DolomiteMarginMath {
// ============ Constants ============
bytes32 internal constant _FILE = "DolomiteMarginMath";
// ============ Library Functions ============
/*
* Return target * (numerator / denominator).
*/
function getPartial(
uint256 target,
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
return target * numerator / denominator;
}
/*
* Return target * (numerator / denominator), but rounded half-up. Meaning, a result of 101.1 rounds to 102
* instead of 101.
*/
function getPartialRoundUp(
uint256 target,
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
if (target == 0 || numerator == 0) {
return 0;
}
return (((target * numerator) - 1) / denominator) + 1;
}
/*
* Return target * (numerator / denominator), but rounded half-up. Meaning, a result of 101.5 rounds to 102
* instead of 101.
*/
function getPartialRoundHalfUp(
uint256 target,
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
if (target == 0 || numerator == 0) {
return 0;
}
return (((target * numerator) + (denominator / 2)) / denominator);
}
function to128(
uint256 number
)
internal
pure
returns (uint128)
{
uint128 result = uint128(number);
Require.that(
result == number,
_FILE,
"Unsafe cast to uint128",
number
);
return result;
}
function to96(
uint256 number
)
internal
pure
returns (uint96)
{
uint96 result = uint96(number);
Require.that(
result == number,
_FILE,
"Unsafe cast to uint96",
number
);
return result;
}
function to32(
uint256 number
)
internal
pure
returns (uint32)
{
uint32 result = uint32(number);
Require.that(
result == number,
_FILE,
"Unsafe cast to uint32",
number
);
return result;
}
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2019 dYdX Trading Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
/**
* @title Require
* @author dYdX
*
* @notice Stringifies parameters to pretty-print revert messages. Costs more gas than regular require()
*/
library Require {
// ============ Constants ============
uint256 private constant _ASCII_ZERO = 48; // '0'
uint256 private constant _ASCII_RELATIVE_ZERO = 87; // 'a' - 10
uint256 private constant _ASCII_LOWER_EX = 120; // 'x'
bytes2 private constant _COLON = 0x3a20; // ': '
bytes2 private constant _COMMA = 0x2c20; // ', '
bytes2 private constant _LPAREN = 0x203c; // ' <'
bytes1 private constant _RPAREN = 0x3e; // '>'
uint256 private constant _FOUR_BIT_MASK = 0xf;
// ============ Library Functions ============
function that(
bool must,
bytes32 file,
bytes32 reason
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringifyTruncated(file),
_COLON,
stringifyTruncated(reason)
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
uint256 payloadA
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringifyTruncated(file),
_COLON,
stringifyTruncated(reason),
_LPAREN,
_stringify(payloadA),
_RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
uint256 payloadA,
uint256 payloadB
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringifyTruncated(file),
_COLON,
stringifyTruncated(reason),
_LPAREN,
_stringify(payloadA),
_COMMA,
_stringify(payloadB),
_RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
address payloadA
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringifyTruncated(file),
_COLON,
stringifyTruncated(reason),
_LPAREN,
_stringify(payloadA),
_RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
address payloadA,
uint256 payloadB
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringifyTruncated(file),
_COLON,
stringifyTruncated(reason),
_LPAREN,
_stringify(payloadA),
_COMMA,
_stringify(payloadB),
_RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
address payloadA,
uint256 payloadB,
uint256 payloadC
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringifyTruncated(file),
_COLON,
stringifyTruncated(reason),
_LPAREN,
_stringify(payloadA),
_COMMA,
_stringify(payloadB),
_COMMA,
_stringify(payloadC),
_RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
bytes32 payloadA
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringifyTruncated(file),
_COLON,
stringifyTruncated(reason),
_LPAREN,
_stringify(payloadA),
_RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
bytes32 payloadA,
uint256 payloadB,
uint256 payloadC
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringifyTruncated(file),
_COLON,
stringifyTruncated(reason),
_LPAREN,
_stringify(payloadA),
_COMMA,
_stringify(payloadB),
_COMMA,
_stringify(payloadC),
_RPAREN
)
)
);
}
}
// ============ Private Functions ============
function stringifyTruncated(
bytes32 input
)
internal
pure
returns (bytes memory)
{
// put the input bytes into the result
bytes memory result = abi.encodePacked(input);
// determine the length of the input by finding the location of the last non-zero byte
for (uint256 i = 32; i > 0; ) {
// reverse-for-loops with unsigned integer
i--;
// find the last non-zero byte in order to determine the length
if (result[i] != 0) {
uint256 length = i + 1;
/* solhint-disable-next-line no-inline-assembly */
assembly {
mstore(result, length) // r.length = length;
}
return result;
}
}
// all bytes are zero
return new bytes(0);
}
function stringifyFunctionSelector(
bytes4 input
)
internal
pure
returns (bytes memory)
{
uint256 z = uint256(bytes32(input) >> 224);
// bytes4 are "0x" followed by 4 bytes of data which take up 2 characters each
bytes memory result = new bytes(10);
// populate the result with "0x"
result[0] = bytes1(uint8(_ASCII_ZERO));
result[1] = bytes1(uint8(_ASCII_LOWER_EX));
// for each byte (starting from the lowest byte), populate the result with two characters
for (uint256 i = 0; i < 4; i++) {
// each byte takes two characters
uint256 shift = i * 2;
// populate the least-significant character
result[9 - shift] = _char(z & _FOUR_BIT_MASK);
z = z >> 4;
// populate the most-significant character
result[8 - shift] = _char(z & _FOUR_BIT_MASK);
z = z >> 4;
}
return result;
}
function _stringify(
uint256 input
)
private
pure
returns (bytes memory)
{
if (input == 0) {
return "0";
}
// get the final string length
uint256 j = input;
uint256 length;
while (j != 0) {
length++;
j /= 10;
}
// allocate the string
bytes memory bstr = new bytes(length);
// populate the string starting with the least-significant character
j = input;
for (uint256 i = length; i > 0; ) {
// reverse-for-loops with unsigned integer
i--;
// take last decimal digit
bstr[i] = bytes1(uint8(_ASCII_ZERO + (j % 10)));
// remove the last decimal digit
j /= 10;
}
return bstr;
}
function _stringify(
address input
)
private
pure
returns (bytes memory)
{
uint256 z = uint256(uint160(input));
// addresses are "0x" followed by 20 bytes of data which take up 2 characters each
bytes memory result = new bytes(42);
// populate the result with "0x"
result[0] = bytes1(uint8(_ASCII_ZERO));
result[1] = bytes1(uint8(_ASCII_LOWER_EX));
// for each byte (starting from the lowest byte), populate the result with two characters
for (uint256 i = 0; i < 20; i++) {
// each byte takes two characters
uint256 shift = i * 2;
// populate the least-significant character
result[41 - shift] = _char(z & _FOUR_BIT_MASK);
z = z >> 4;
// populate the most-significant character
result[40 - shift] = _char(z & _FOUR_BIT_MASK);
z = z >> 4;
}
return result;
}
function _stringify(
bytes32 input
)
private
pure
returns (bytes memory)
{
uint256 z = uint256(input);
// bytes32 are "0x" followed by 32 bytes of data which take up 2 characters each
bytes memory result = new bytes(66);
// populate the result with "0x"
result[0] = bytes1(uint8(_ASCII_ZERO));
result[1] = bytes1(uint8(_ASCII_LOWER_EX));
// for each byte (starting from the lowest byte), populate the result with two characters
for (uint256 i = 0; i < 32; i++) {
// each byte takes two characters
uint256 shift = i * 2;
// populate the least-significant character
result[65 - shift] = _char(z & _FOUR_BIT_MASK);
z = z >> 4;
// populate the most-significant character
result[64 - shift] = _char(z & _FOUR_BIT_MASK);
z = z >> 4;
}
return result;
}
function _char(
uint256 input
)
private
pure
returns (bytes1)
{
// return ASCII digit (0-9)
if (input < 10) {
return bytes1(uint8(input + _ASCII_ZERO));
}
// return ASCII letter (a-f)
return bytes1(uint8(input + _ASCII_RELATIVE_ZERO));
}
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2019 dYdX Trading Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { DolomiteMarginMath } from "./DolomiteMarginMath.sol";
import { IDolomiteStructs } from "../interfaces/IDolomiteStructs.sol";
/**
* @title TypesLib
* @author dYdX
*
* @notice Library for interacting with the basic structs used in DolomiteMargin
*/
library TypesLib {
using DolomiteMarginMath for uint256;
// ============ Par (Principal Amount) ============
function zeroPar()
internal
pure
returns (IDolomiteStructs.Par memory)
{
return IDolomiteStructs.Par({
sign: false,
value: 0
});
}
function sub(
IDolomiteStructs.Par memory a,
IDolomiteStructs.Par memory b
)
internal
pure
returns (IDolomiteStructs.Par memory)
{
return add(a, negative(b));
}
function add(
IDolomiteStructs.Par memory a,
IDolomiteStructs.Par memory b
)
internal
pure
returns (IDolomiteStructs.Par memory)
{
IDolomiteStructs.Par memory result;
if (a.sign == b.sign) {
result.sign = a.sign;
result.value = a.value + b.value;
} else {
if (a.value >= b.value) {
result.sign = a.sign;
result.value = a.value - b.value;
} else {
result.sign = b.sign;
result.value = b.value - a.value;
}
}
return result;
}
function equals(
IDolomiteStructs.Par memory a,
IDolomiteStructs.Par memory b
)
internal
pure
returns (bool)
{
if (a.value == b.value) {
if (a.value == 0) {
return true;
}
return a.sign == b.sign;
}
return false;
}
function negative(
IDolomiteStructs.Par memory a
)
internal
pure
returns (IDolomiteStructs.Par memory)
{
return IDolomiteStructs.Par({
sign: !a.sign,
value: a.value
});
}
function isNegative(
IDolomiteStructs.Par memory a
)
internal
pure
returns (bool)
{
return !a.sign && a.value > 0;
}
function isPositive(
IDolomiteStructs.Par memory a
)
internal
pure
returns (bool)
{
return a.sign && a.value > 0;
}
function isZero(
IDolomiteStructs.Par memory a
)
internal
pure
returns (bool)
{
return a.value == 0;
}
function isLessThanZero(
IDolomiteStructs.Par memory a
)
internal
pure
returns (bool)
{
return a.value > 0 && !a.sign;
}
function isGreaterThanOrEqualToZero(
IDolomiteStructs.Par memory a
)
internal
pure
returns (bool)
{
return isZero(a) || a.sign;
}
// ============ Wei (Token Amount) ============
function zeroWei()
internal
pure
returns (IDolomiteStructs.Wei memory)
{
return IDolomiteStructs.Wei({
sign: false,
value: 0
});
}
function sub(
IDolomiteStructs.Wei memory a,
IDolomiteStructs.Wei memory b
)
internal
pure
returns (IDolomiteStructs.Wei memory)
{
return add(a, negative(b));
}
function add(
IDolomiteStructs.Wei memory a,
IDolomiteStructs.Wei memory b
)
internal
pure
returns (IDolomiteStructs.Wei memory)
{
IDolomiteStructs.Wei memory result;
if (a.sign == b.sign) {
result.sign = a.sign;
result.value = a.value + b.value;
} else {
if (a.value >= b.value) {
result.sign = a.sign;
result.value = a.value - b.value;
} else {
result.sign = b.sign;
result.value = b.value - a.value;
}
}
return result;
}
function equals(
IDolomiteStructs.Wei memory a,
IDolomiteStructs.Wei memory b
)
internal
pure
returns (bool)
{
if (a.value == b.value) {
if (a.value == 0) {
return true;
}
return a.sign == b.sign;
}
return false;
}
function negative(
IDolomiteStructs.Wei memory a
)
internal
pure
returns (IDolomiteStructs.Wei memory)
{
return IDolomiteStructs.Wei({
sign: !a.sign,
value: a.value
});
}
function isNegative(
IDolomiteStructs.Wei memory a
)
internal
pure
returns (bool)
{
return !a.sign && a.value > 0;
}
function isPositive(
IDolomiteStructs.Wei memory a
)
internal
pure
returns (bool)
{
return a.sign && a.value > 0;
}
function isZero(
IDolomiteStructs.Wei memory a
)
internal
pure
returns (bool)
{
return a.value == 0;
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/**
* @title ICustomTestToken
* @author Dolomite
*
* @notice Interface contract for accessing test methods on test ERC20s for testing.
*/
interface ICustomTestToken is IERC20 {
function addBalance(address _receiver, uint256 _amount) external;
function burn(uint256 _amount) external;
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { ICustomTestToken } from "./ICustomTestToken.sol";
/**
* @title ICustomTestVaultToken
* @author Dolomite
*
* @notice Interface contract for accessing test methods on test ERC4626 for testing.
*/
interface ICustomTestVaultToken is ICustomTestToken {
function addBalance(address _receiver, uint256 _amount) external;
function totalAssets() external view returns (uint256);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
pragma solidity ^0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```solidity
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
* unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
* array of EnumerableSet.
* ====
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastValue;
// Update the index for the moved value
set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IChainlinkAutomationPriceOracle } from "./interfaces/IChainlinkAutomationPriceOracle.sol";
import { IChainlinkAutomationRegistry } from "./interfaces/IChainlinkAutomationRegistry.sol";
/**
* @title ChainlinkAutomationPriceOracle
* @author Dolomite
*
* @notice An abstract contract that implements the IChainlinkAutomationPriceOracle interface
* @notice Contains variables and functions for Chainlink Automation
*/
abstract contract ChainlinkAutomationPriceOracle is IChainlinkAutomationPriceOracle, OnlyDolomiteMargin {
// ============================ Constants ============================
bytes32 private constant _FILE = "ChainlinkAutomationPriceOracle";
uint256 private constant _ONE_UNIT = 10 ** 18;
// ============================ Public State Variables ============================
uint256 public heartbeat;
uint256 public gracePeriod;
uint256 public upperEdge;
uint256 public lowerEdge;
address public chainlinkRegistry;
address public forwarder;
uint256 public exchangeRateNumerator;
uint256 public exchangeRateDenominator;
uint256 public lastUpdateTimestamp;
// ============================ Constructor ============================
constructor(
address _dolomiteMargin,
address _chainlinkRegistry
) OnlyDolomiteMargin(_dolomiteMargin) {
_ownerSetHeartbeat(24 hours);
_ownerSetGracePeriod(1 hours);
_ownerSetUpperEdge(10_025);
_ownerSetLowerEdge(9_975);
_ownerSetChainlinkRegistry(_chainlinkRegistry);
}
function ownerSetHeartbeat(uint256 _heartbeat) external onlyDolomiteMarginOwner(msg.sender) {
_ownerSetHeartbeat(_heartbeat);
}
function ownerSetGracePeriod(uint256 _gracePeriod) external onlyDolomiteMarginOwner(msg.sender) {
_ownerSetGracePeriod(_gracePeriod);
}
function ownerSetUpperEdge(uint256 _upperEdge) external onlyDolomiteMarginOwner(msg.sender) {
_ownerSetUpperEdge(_upperEdge);
}
function ownerSetLowerEdge(uint256 _lowerEdge) external onlyDolomiteMarginOwner(msg.sender) {
_ownerSetLowerEdge(_lowerEdge);
}
function ownerSetChainlinkRegistry(address _chainlinkRegistry) external onlyDolomiteMarginOwner(msg.sender) {
_ownerSetChainlinkRegistry(_chainlinkRegistry);
}
function ownerSetForwarder(address _forwarder) external onlyDolomiteMarginOwner(msg.sender) {
_ownerSetForwarder(_forwarder);
}
function initializeForwarder(uint256 _upkeepId) external {
Require.that(
forwarder == address(0),
_FILE,
"Forwarder already initialized"
);
_ownerSetForwarder(IChainlinkAutomationRegistry(chainlinkRegistry).getForwarder(_upkeepId));
}
function checkUpkeep(
bytes calldata /* checkData */
)
external
returns (bool upkeepNeeded, bytes memory /* performData */)
{
// solhint-disable avoid-tx-origin
Require.that(
tx.origin == address(0),
_FILE,
"Static rpc calls only"
);
// solhint-enable avoid-tx-origin
return (_checkUpkeepConditions(), bytes(""));
}
function performUpkeep(bytes calldata /* performData */) external {
Require.that(
msg.sender == forwarder,
_FILE,
"Caller is not forwarder"
);
Require.that(
_checkUpkeepConditions(),
_FILE,
"checkUpkeep conditions not met"
);
_updateExchangeRateAndTimestamp();
}
// ============================ Internal Functions ============================
function _ownerSetHeartbeat(uint256 _heartbeat) internal {
heartbeat = _heartbeat;
emit HeartbeatSet(_heartbeat);
}
function _ownerSetGracePeriod(uint256 _gracePeriod) internal {
gracePeriod = _gracePeriod;
emit GracePeriodSet(_gracePeriod);
}
function _ownerSetUpperEdge(uint256 _upperEdge) internal {
Require.that(
_upperEdge > 10_000,
_FILE,
"Invalid upper edge"
);
upperEdge = _upperEdge;
emit UpperEdgeSet(_upperEdge);
}
function _ownerSetLowerEdge(uint256 _lowerEdge) internal {
Require.that(
_lowerEdge < 10_000,
_FILE,
"Invalid lower edge"
);
lowerEdge = _lowerEdge;
emit LowerEdgeSet(_lowerEdge);
}
function _ownerSetChainlinkRegistry(address _chainlinkRegistry) internal {
Require.that(
_chainlinkRegistry != address(0),
_FILE,
"Invalid chainlink registry"
);
chainlinkRegistry = _chainlinkRegistry;
emit ChainlinkRegistrySet(_chainlinkRegistry);
}
function _ownerSetForwarder(address _forwarder) internal {
Require.that(
_forwarder != address(0),
_FILE,
"Invalid forwarder"
);
forwarder = _forwarder;
emit ForwarderSet(_forwarder);
}
function _updateExchangeRateAndTimestamp() internal {
(exchangeRateNumerator, exchangeRateDenominator) = _getExchangeRate();
lastUpdateTimestamp = block.timestamp;
emit ExchangeRateUpdated(lastUpdateTimestamp, exchangeRateNumerator, exchangeRateDenominator);
}
function _checkUpkeepConditions() internal view returns (bool) {
(uint256 currentNumerator, uint256 currentDenominator) = _getExchangeRate();
if (currentDenominator == 0) {
return false;
}
uint256 cachedExchangeRate = exchangeRateNumerator * _ONE_UNIT / exchangeRateDenominator;
uint256 currentExchangeRate = currentNumerator * _ONE_UNIT / currentDenominator;
uint256 upperExchangeRate = cachedExchangeRate * upperEdge / 10_000;
uint256 lowerExchangeRate = cachedExchangeRate * lowerEdge / 10_000;
return (
currentExchangeRate >= upperExchangeRate ||
currentExchangeRate <= lowerExchangeRate ||
block.timestamp >= lastUpdateTimestamp + heartbeat
);
}
function _checkIsPriceExpired() internal view {
Require.that(
lastUpdateTimestamp + heartbeat + gracePeriod > block.timestamp,
_FILE,
"Price is expired"
);
}
// ============================ Virtual Functions ============================
function _getExchangeRate() internal virtual view returns (uint256 numerator, uint256 denominator);
function _getCurrentPrice() internal virtual view returns (uint256);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IChainlinkAccessControlAggregator } from "./interfaces/IChainlinkAccessControlAggregator.sol";
import { IChainlinkAggregator } from "./interfaces/IChainlinkAggregator.sol";
import { IChainlinkPriceOracleV1 } from "./interfaces/IChainlinkPriceOracleV1.sol";
/**
* @title ChainlinkPriceOracleV1
* @author Dolomite
*
* An implementation of the IDolomitePriceOracle interface that makes Chainlink prices compatible with the protocol.
*/
contract ChainlinkPriceOracleV1 is IChainlinkPriceOracleV1, OnlyDolomiteMargin {
// ========================= Constants =========================
bytes32 private constant _FILE = "ChainlinkPriceOracleV1";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
// ========================= Storage =========================
mapping(address => IChainlinkAggregator) private _tokenToAggregatorMap;
mapping(address => uint8) private _tokenToDecimalsMap;
/// @dev Defaults to USD if the value is the ZERO address
mapping(address => address) private _tokenToPairingMap;
uint256 public stalenessThreshold;
// ========================= Constructor =========================
/**
* Note, these arrays are set up such that each index corresponds with one-another.
*
* @param _tokens The tokens that are supported by this adapter.
* @param _chainlinkAggregators The Chainlink aggregators that have on-chain prices.
* @param _tokenDecimals The number of decimals that each token has.
* @param _tokenPairs The token against which this token's value is compared using the aggregator. The
* zero address means USD.
* @param _dolomiteMargin The address of the DolomiteMargin contract.
*/
constructor(
address[] memory _tokens,
address[] memory _chainlinkAggregators,
uint8[] memory _tokenDecimals,
address[] memory _tokenPairs,
address _dolomiteMargin
)
OnlyDolomiteMargin(_dolomiteMargin)
{
Require.that(
_tokens.length == _chainlinkAggregators.length,
_FILE,
"Invalid tokens length"
);
Require.that(
_chainlinkAggregators.length == _tokenDecimals.length,
_FILE,
"Invalid aggregators length"
);
Require.that(
_tokenDecimals.length == _tokenPairs.length,
_FILE,
"Invalid decimals length"
);
uint256 tokensLength = _tokens.length;
for (uint256 i; i < tokensLength; ++i) {
_ownerInsertOrUpdateOracleToken(
_tokens[i],
_tokenDecimals[i],
_chainlinkAggregators[i],
_tokenPairs[i]
);
}
_ownerSetStalenessThreshold(36 hours);
}
// ========================= Admin Functions =========================
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerSetStalenessThreshold(_stalenessThreshold);
}
function ownerInsertOrUpdateOracleToken(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerInsertOrUpdateOracleToken(
_token,
_tokenDecimals,
_chainlinkAggregator,
_tokenPair
);
}
// ========================= Public Functions =========================
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory)
{
Require.that(
address(_tokenToAggregatorMap[_token]) != address(0),
_FILE,
"Invalid token",
_token
);
IChainlinkAggregator aggregatorProxy = _tokenToAggregatorMap[_token];
(
/* uint80 roundId */,
int256 answer,
/* uint256 startedAt */,
uint256 updatedAt,
/* uint80 answeredInRound */
) = aggregatorProxy.latestRoundData();
Require.that(
block.timestamp - updatedAt < stalenessThreshold,
_FILE,
"Chainlink price expired",
_token
);
IChainlinkAccessControlAggregator controlAggregator = aggregatorProxy.aggregator();
Require.that(
controlAggregator.minAnswer() < answer,
_FILE,
"Chainlink price too low"
);
Require.that(
answer < controlAggregator.maxAnswer(),
_FILE,
"Chainlink price too high"
);
uint256 chainlinkPrice = uint256(answer);
address tokenPair = _tokenToPairingMap[_token];
// standardize the Chainlink price to be the proper number of decimals of (36 - tokenDecimals)
uint256 standardizedPrice = standardizeNumberOfDecimals(
_tokenToDecimalsMap[_token],
chainlinkPrice,
aggregatorProxy.decimals()
);
if (tokenPair == address(0)) {
// The pair has a USD base, we are done.
return IDolomiteStructs.MonetaryPrice({
value: standardizedPrice
});
} else {
// The price we just got and converted is NOT against USD. So we need to get its pair's price against USD.
// We can do so by recursively calling #getPrice using the `tokenPair` as the parameter instead of `token`.
uint256 tokenPairPrice = getPrice(tokenPair).value;
// Standardize the price to use 36 decimals.
uint256 tokenPairWith36Decimals = tokenPairPrice * (10 ** uint256(_tokenToDecimalsMap[tokenPair]));
// Now that the chained price uses 36 decimals (and thus is standardized), we can do easy math.
return IDolomiteStructs.MonetaryPrice({
value: standardizedPrice * tokenPairWith36Decimals / _ONE_DOLLAR
});
}
}
function getAggregatorByToken(address _token) public view returns (IChainlinkAggregator) {
return _tokenToAggregatorMap[_token];
}
function getDecimalsByToken(address _token) public view returns (uint8) {
return _tokenToDecimalsMap[_token];
}
function getTokenPairByToken(address _token) public view returns (address _tokenPair) {
return _tokenToPairingMap[_token];
}
/**
* Standardizes `value` to have `ONE_DOLLAR.decimals` - `tokenDecimals` number of decimals.
*/
function standardizeNumberOfDecimals(
uint8 _tokenDecimals,
uint256 _value,
uint8 _valueDecimals
)
public
pure
returns (uint)
{
uint256 tokenDecimalsFactor = 10 ** uint256(_tokenDecimals);
uint256 priceFactor = _ONE_DOLLAR / tokenDecimalsFactor;
uint256 valueFactor = 10 ** uint256(_valueDecimals);
return _value * priceFactor / valueFactor;
}
// ========================= Internal Functions =========================
function _ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
internal
{
Require.that(
_stalenessThreshold >= 24 hours,
_FILE,
"Staleness threshold too low",
_stalenessThreshold
);
Require.that(
_stalenessThreshold <= 7 days,
_FILE,
"Staleness threshold too high",
_stalenessThreshold
);
stalenessThreshold = _stalenessThreshold;
emit StalenessDurationUpdated(_stalenessThreshold);
}
function _ownerInsertOrUpdateOracleToken(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair
) internal {
_tokenToAggregatorMap[_token] = IChainlinkAggregator(_chainlinkAggregator);
_tokenToDecimalsMap[_token] = _tokenDecimals;
if (_tokenPair != address(0)) {
Require.that(
address(_tokenToAggregatorMap[_tokenPair]) != address(0),
_FILE,
"Invalid token pair",
_tokenPair
);
// The aggregator's price is NOT against USD. Therefore, we need to store what it's against as well as the
// # of decimals the aggregator's price has.
_tokenToPairingMap[_token] = _tokenPair;
}
emit TokenInsertedOrUpdated(_token, _chainlinkAggregator, _tokenPair);
}
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IChainlinkAccessControlAggregator } from "./interfaces/IChainlinkAccessControlAggregator.sol";
import { IChainlinkAggregator } from "./interfaces/IChainlinkAggregator.sol";
import { IChainlinkPriceOracleV2 } from "./interfaces/IChainlinkPriceOracleV2.sol";
/**
* @title ChainlinkPriceOracleV2
* @author Dolomite
*
* An implementation of the IDolomitePriceOracle interface that makes Chainlink prices compatible with the protocol.
*/
contract ChainlinkPriceOracleV2 is IChainlinkPriceOracleV2, OnlyDolomiteMargin {
// ========================= Constants =========================
bytes32 private constant _FILE = "ChainlinkPriceOracleV2";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
// ========================= Storage =========================
mapping(address => IChainlinkAggregator) private _tokenToAggregatorMap;
mapping(address => uint8) private _tokenToDecimalsMap;
/// @dev Defaults to USD if the value is the ZERO address
mapping(address => address) private _tokenToPairingMap;
mapping(address => bool) private _tokenToBypassUsdValueMap;
uint256 public stalenessThreshold;
// ========================= Constructor =========================
/**
* Note, these arrays are set up such that each index corresponds with one-another.
*
* @param _tokens The tokens that are supported by this adapter.
* @param _chainlinkAggregators The Chainlink aggregators that have on-chain prices.
* @param _tokenDecimals The number of decimals that each token has.
* @param _tokenPairs The token against which this token's value is compared using the aggregator. The
* zero address means USD.
* @param _tokenToBypassUsdValue True if the token does NOT return a USD value
* @param _dolomiteMargin The address of the DolomiteMargin contract.
*/
constructor(
address[] memory _tokens,
address[] memory _chainlinkAggregators,
uint8[] memory _tokenDecimals,
address[] memory _tokenPairs,
bool[] memory _tokenToBypassUsdValue,
address _dolomiteMargin
)
OnlyDolomiteMargin(_dolomiteMargin)
{
Require.that(
_tokens.length == _chainlinkAggregators.length,
_FILE,
"Invalid tokens length"
);
Require.that(
_chainlinkAggregators.length == _tokenDecimals.length,
_FILE,
"Invalid aggregators length"
);
Require.that(
_tokenDecimals.length == _tokenPairs.length,
_FILE,
"Invalid decimals length"
);
Require.that(
_tokenPairs.length == _tokenToBypassUsdValue.length,
_FILE,
"Invalid pairs length"
);
uint256 tokensLength = _tokens.length;
for (uint256 i; i < tokensLength; ++i) {
_ownerInsertOrUpdateOracleToken(
_tokens[i],
_tokenDecimals[i],
_chainlinkAggregators[i],
_tokenPairs[i],
_tokenToBypassUsdValue[i]
);
}
_ownerSetStalenessThreshold(36 hours);
}
// ========================= Admin Functions =========================
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerSetStalenessThreshold(_stalenessThreshold);
}
function ownerInsertOrUpdateOracleTokenWithBypass(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair,
bool _bypassUsdValue
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerInsertOrUpdateOracleToken(
_token,
_tokenDecimals,
_chainlinkAggregator,
_tokenPair,
_bypassUsdValue
);
}
function ownerInsertOrUpdateOracleToken(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerInsertOrUpdateOracleToken(
_token,
_tokenDecimals,
_chainlinkAggregator,
_tokenPair,
false
);
}
// ========================= Public Functions =========================
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory)
{
Require.that(
address(_tokenToAggregatorMap[_token]) != address(0),
_FILE,
"Invalid token",
_token
);
if (_tokenToBypassUsdValueMap[_token]) {
Require.that(
msg.sender != address(DOLOMITE_MARGIN()),
_FILE,
"Token bypasses USD value",
_token
);
}
IChainlinkAggregator aggregatorProxy = _tokenToAggregatorMap[_token];
(
/* uint80 roundId */,
int256 answer,
/* uint256 startedAt */,
uint256 updatedAt,
/* uint80 answeredInRound */
) = aggregatorProxy.latestRoundData();
Require.that(
block.timestamp - updatedAt < stalenessThreshold,
_FILE,
"Chainlink price expired",
_token
);
IChainlinkAccessControlAggregator controlAggregator = aggregatorProxy.aggregator();
Require.that(
controlAggregator.minAnswer() < answer,
_FILE,
"Chainlink price too low"
);
Require.that(
answer < controlAggregator.maxAnswer(),
_FILE,
"Chainlink price too high"
);
uint256 chainlinkPrice = uint256(answer);
address tokenPair = _tokenToPairingMap[_token];
// standardize the Chainlink price to be the proper number of decimals of (36 - tokenDecimals)
uint256 standardizedPrice = standardizeNumberOfDecimals(
_tokenToDecimalsMap[_token],
chainlinkPrice,
aggregatorProxy.decimals()
);
if (tokenPair == address(0)) {
// The pair has a USD base or can bypass USD pairing, we are done.
return IDolomiteStructs.MonetaryPrice({
value: standardizedPrice
});
} else {
// The price we just got and converted is NOT against USD. So we need to get its pair's price against USD.
// We can do so by recursively calling #getPrice using the `tokenPair` as the parameter instead of `token`.
uint256 tokenPairPrice = getPrice(tokenPair).value;
// Standardize the price to use 36 decimals.
uint256 tokenPairWith36Decimals = tokenPairPrice * (10 ** uint256(_tokenToDecimalsMap[tokenPair]));
// Now that the chained price uses 36 decimals (and thus is standardized), we can do easy math.
return IDolomiteStructs.MonetaryPrice({
value: standardizedPrice * tokenPairWith36Decimals / _ONE_DOLLAR
});
}
}
function getAggregatorByToken(address _token) public view returns (IChainlinkAggregator) {
return _tokenToAggregatorMap[_token];
}
function getDecimalsByToken(address _token) public view returns (uint8) {
return _tokenToDecimalsMap[_token];
}
function getTokenPairByToken(address _token) public view returns (address _tokenPair) {
return _tokenToPairingMap[_token];
}
function getBypassUsdValueByToken(address _token) public view returns (bool) {
return _tokenToBypassUsdValueMap[_token];
}
/**
* Standardizes `value` to have `ONE_DOLLAR.decimals` - `tokenDecimals` number of decimals.
*/
function standardizeNumberOfDecimals(
uint8 _tokenDecimals,
uint256 _value,
uint8 _valueDecimals
)
public
pure
returns (uint)
{
uint256 tokenDecimalsFactor = 10 ** uint256(_tokenDecimals);
uint256 priceFactor = _ONE_DOLLAR / tokenDecimalsFactor;
uint256 valueFactor = 10 ** uint256(_valueDecimals);
return _value * priceFactor / valueFactor;
}
// ========================= Internal Functions =========================
function _ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
internal
{
Require.that(
_stalenessThreshold >= 24 hours,
_FILE,
"Staleness threshold too low",
_stalenessThreshold
);
Require.that(
_stalenessThreshold <= 7 days,
_FILE,
"Staleness threshold too high",
_stalenessThreshold
);
stalenessThreshold = _stalenessThreshold;
emit StalenessDurationUpdated(_stalenessThreshold);
}
function _ownerInsertOrUpdateOracleToken(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair,
bool _bypassUsdValue
) internal {
_tokenToAggregatorMap[_token] = IChainlinkAggregator(_chainlinkAggregator);
_tokenToDecimalsMap[_token] = _tokenDecimals;
_tokenToBypassUsdValueMap[_token] = _bypassUsdValue;
if (_tokenPair != address(0)) {
Require.that(
address(_tokenToAggregatorMap[_tokenPair]) != address(0),
_FILE,
"Invalid token pair",
_tokenPair
);
// The aggregator's price is NOT against USD. Therefore, we need to store what it's against as well as the
// # of decimals the aggregator's price has.
_tokenToPairingMap[_token] = _tokenPair;
}
emit TokenInsertedOrUpdated(_token, _chainlinkAggregator, _tokenPair);
}
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomiteRegistry } from "@dolomite-exchange/modules-base/contracts/interfaces/IDolomiteRegistry.sol";
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IChainlinkAccessControlAggregator } from "./interfaces/IChainlinkAccessControlAggregator.sol";
import { IChainlinkAggregator } from "./interfaces/IChainlinkAggregator.sol";
import { IChainlinkPriceOracleV3 } from "./interfaces/IChainlinkPriceOracleV3.sol";
import { IOracleAggregatorV2 } from "./interfaces/IOracleAggregatorV2.sol";
/**
* @title ChainlinkPriceOracleV3
* @author Dolomite
*
* An implementation of the IDolomitePriceOracle interface that makes Chainlink prices compatible with the protocol.
* This implementation is meant to be tied to an
*/
contract ChainlinkPriceOracleV3 is IChainlinkPriceOracleV3, OnlyDolomiteMargin {
// ========================= Constants =========================
bytes32 private constant _FILE = "ChainlinkPriceOracleV3";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
// ========================= Storage =========================
mapping(address => IChainlinkAggregator) private _tokenToAggregatorMap;
mapping(address => bool) private _tokenToInvertPriceMap;
IDolomiteRegistry public immutable DOLOMITE_REGISTRY;
uint256 public stalenessThreshold;
// ========================= Constructor =========================
/**
* Note, these arrays are set up such that each index corresponds with one-another.
*
* @param _tokens The tokens that are supported by this adapter.
* @param _chainlinkAggregators The Chainlink aggregators that have on-chain prices.
* @param _invertPrice True if should invert price received from Chainlink
* @param _dolomiteRegistry The address of the DolomiteRegistry contract.
* @param _dolomiteMargin The address of the DolomiteMargin contract.
*/
constructor(
address[] memory _tokens,
address[] memory _chainlinkAggregators,
bool[] memory _invertPrice,
address _dolomiteRegistry,
address _dolomiteMargin
)
OnlyDolomiteMargin(_dolomiteMargin)
{
Require.that(
_tokens.length == _chainlinkAggregators.length,
_FILE,
"Invalid tokens length"
);
Require.that(
_chainlinkAggregators.length == _invertPrice.length,
_FILE,
"Invalid aggregators length"
);
uint256 tokensLength = _tokens.length;
for (uint256 i; i < tokensLength; ++i) {
_ownerInsertOrUpdateOracleToken(
_tokens[i],
_chainlinkAggregators[i],
_invertPrice[i]
);
}
_ownerSetStalenessThreshold(36 hours);
DOLOMITE_REGISTRY = IDolomiteRegistry(_dolomiteRegistry);
}
// ========================= Admin Functions =========================
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerSetStalenessThreshold(_stalenessThreshold);
}
function ownerInsertOrUpdateOracleToken(
address _token,
address _chainlinkAggregator,
bool _invertPrice
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerInsertOrUpdateOracleToken(
_token,
_chainlinkAggregator,
_invertPrice
);
}
// ========================= Public Functions =========================
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory)
{
Require.that(
address(_tokenToAggregatorMap[_token]) != address(0),
_FILE,
"Invalid token",
_token
);
Require.that(
msg.sender != address(DOLOMITE_MARGIN()),
_FILE,
"DolomiteMargin cannot call"
);
IChainlinkAggregator aggregatorProxy = _tokenToAggregatorMap[_token];
(
/* uint80 roundId */,
int256 answer,
/* uint256 startedAt */,
uint256 updatedAt,
/* uint80 answeredInRound */
) = aggregatorProxy.latestRoundData();
Require.that(
block.timestamp - updatedAt < stalenessThreshold,
_FILE,
"Chainlink price expired",
_token,
updatedAt
);
IChainlinkAccessControlAggregator controlAggregator = aggregatorProxy.aggregator();
Require.that(
controlAggregator.minAnswer() < answer,
_FILE,
"Chainlink price too low"
);
Require.that(
answer < controlAggregator.maxAnswer(),
_FILE,
"Chainlink price too high"
);
uint256 chainlinkPrice = uint256(answer);
uint8 valueDecimals = aggregatorProxy.decimals();
if (_tokenToInvertPriceMap[_token]) {
uint256 decimalFactor = 10 ** uint256(valueDecimals);
chainlinkPrice = (decimalFactor ** 2) / chainlinkPrice;
}
// standardize the Chainlink price to be the proper number of decimals of (36 - tokenDecimals)
IOracleAggregatorV2 aggregator = IOracleAggregatorV2(address(DOLOMITE_REGISTRY.oracleAggregator()));
uint8 tokenDecimals = aggregator.getDecimalsByToken(_token);
assert(tokenDecimals > 0);
uint256 standardizedPrice = standardizeNumberOfDecimals(
tokenDecimals,
chainlinkPrice,
valueDecimals
);
return IDolomiteStructs.MonetaryPrice({
value: standardizedPrice
});
}
function getAggregatorByToken(address _token) public view returns (IChainlinkAggregator) {
return _tokenToAggregatorMap[_token];
}
function getInvertPriceByToken(address _token) public view returns (bool _invertPrice) {
return _tokenToInvertPriceMap[_token];
}
/**
* Standardizes `value` to have `ONE_DOLLAR.decimals` - `tokenDecimals` number of decimals.
*/
function standardizeNumberOfDecimals(
uint8 _tokenDecimals,
uint256 _value,
uint8 _valueDecimals
)
public
pure
returns (uint)
{
uint256 tokenDecimalsFactor = 10 ** uint256(_tokenDecimals);
uint256 priceFactor = _ONE_DOLLAR / tokenDecimalsFactor;
uint256 valueFactor = 10 ** uint256(_valueDecimals);
return _value * priceFactor / valueFactor;
}
// ========================= Internal Functions =========================
function _ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
internal
{
Require.that(
_stalenessThreshold >= 24 hours,
_FILE,
"Staleness threshold too low",
_stalenessThreshold
);
Require.that(
_stalenessThreshold <= 7 days,
_FILE,
"Staleness threshold too high",
_stalenessThreshold
);
stalenessThreshold = _stalenessThreshold;
emit StalenessDurationUpdated(_stalenessThreshold);
}
function _ownerInsertOrUpdateOracleToken(
address _token,
address _chainlinkAggregator,
bool _invertPrice
) internal {
_tokenToAggregatorMap[_token] = IChainlinkAggregator(_chainlinkAggregator);
_tokenToInvertPriceMap[_token] = _invertPrice;
emit TokenInsertedOrUpdated(_token, _chainlinkAggregator);
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
/**
* @title IAlgebraV3Pool
* @author Dolomite
*
* @notice Interface for Algebra V3 pools
*/
interface IAlgebraV3Pool {
function getTimepoints(
uint32[] calldata secondsAgos
)
external
view
returns (
int56[] memory tickCumulatives,
uint160[] memory secondsPerLiquidityCumulatives,
uint112[] memory volatilityCumulatives,
uint256[] memory volumePerAvgLiquiditys
);
function token0() external view returns (address);
function token1() external view returns (address);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
/**
* @title IChainlinkAccessControlAggregator
* @author Dolomite
*
* Gets configuration for an aggregator proxy
*/
interface IChainlinkAccessControlAggregator {
function minAnswer() external view returns (int192);
function maxAnswer() external view returns (int192);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IChainlinkAccessControlAggregator } from "./IChainlinkAccessControlAggregator.sol";
/**
* @title IChainlinkAggregator
* @author Dolomite
*
* Gets the latest price from the Chainlink Oracle Network. Amount of decimals depends on the base.
*/
interface IChainlinkAggregator {
function aggregator() external view returns (IChainlinkAccessControlAggregator);
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
/**
* @title IChainlinkAutomation
* @author Dolomite
*
* @dev Chainlink Automation enables conditional execution of your smart contracts functions through a
* hyper-reliable and decentralized automation platform that uses the same external network of node operators
* that secures billions in value. The documentation is copied from Chainlink's official documentation.
*/
interface IChainlinkAutomation {
/**
* @notice The method that is simulated by keepers to see if any work actually needs to be performed. This method
* does does not actually need to be executable, and since it is only ever simulated it can consume a lot
* of gas.
*
* @dev To ensure that it is never called, you may want to add the `cannotExecute` modifier from `KeeperBase` to
* your implementation of this method.
*
* @param _checkData specified in the upkeep registration so it is always the same for a registered upkeep.
* This can easily be broken down into specific arguments using `abi.decode`, so multiple
* up-keeps can be registered on the same contract and easily differentiated by the
* contract.
* @return upkeepNeeded A boolean to indicate whether the keeper should call `performUpkeep` or not.
* @return performData The bytes that the keeper should call `performUpkeep` with, if upkeep is needed. If you
* would like to encode data to decode later, try `abi.encode`.
*/
function checkUpkeep(bytes calldata _checkData) external returns (bool upkeepNeeded, bytes memory performData);
/**
* @notice The method that is actually executed by the keepers, via the registry. The data returned by the
* `checkUpkeep` simulation will be passed into this method to actually be executed.
* @dev The input to this method should not be trusted, and the caller of the method should not even be
* restricted to any single registry. Anyone should be able call it, and the input should be validated,
* there is no guarantee that the data passed in is the _performData returned from checkUpkeep. This could
* happen due to malicious keepers, racing keepers, or simply a state change while the `performUpkeep`
* transaction is waiting for confirmation. Always validate the data passed in.
*
* @param _performData The data which was passed back from the `_checkData` simulation. If it is encoded, it
* can easily be decoded into other types by calling `abi.decode`. This data should not be
* trusted, and should be validated against the contract's current state.
*/
function performUpkeep(bytes calldata _performData) external;
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IOnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/interfaces/IOnlyDolomiteMargin.sol";
import { IDolomitePriceOracle } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomitePriceOracle.sol"; // solhint-disable-line max-line-length
import { IChainlinkAutomation } from "./IChainlinkAutomation.sol";
/**
* @title IChainlinkAutomationPriceOracle
* @author Dolomite
*
* @notice A contract that implements the IDolomitePriceOracle interface using Chainlink Automation
*/
interface IChainlinkAutomationPriceOracle is IDolomitePriceOracle, IChainlinkAutomation, IOnlyDolomiteMargin {
// ================================================
// ==================== Events ====================
// ================================================
event HeartbeatSet(uint256 _heartbeat);
event GracePeriodSet(uint256 _heartbeat);
event UpperEdgeSet(uint256 _upperEdge);
event LowerEdgeSet(uint256 _lowerEdge);
event ChainlinkRegistrySet(address _chainlinkRegistry);
event ForwarderSet(address _forwarder);
event ExchangeRateUpdated(
uint256 _lastUpdateTimestamp,
uint256 _exchangeRateNumerator,
uint256 _exchangeRateDenominator
);
// ========================================================
// =================== Admin Functions ====================
// ========================================================
/**
*
* @param _heartbeat The new heartbeat for Chainlink automation
*/
function ownerSetHeartbeat(uint256 _heartbeat) external;
/**
*
* @param _gracePeriod The new grace period for the getPrice function
*/
function ownerSetGracePeriod(uint256 _gracePeriod) external;
/**
*
* @param _upperEdge The new deviation upper edge for Chainlink automation
*/
function ownerSetUpperEdge(uint256 _upperEdge) external;
/**
*
* @param _lowerEdge The new deviation lower edge for Chainlink automation
*/
function ownerSetLowerEdge(uint256 _lowerEdge) external;
/**
*
* @param _chainlinkRegistry The new address of the chainlink registry
*/
function ownerSetChainlinkRegistry(address _chainlinkRegistry) external;
/**
*
* @param _forwarder The new address of the chainlink forwarder for interacting with this contract
*/
function ownerSetForwarder(address _forwarder) external;
// ========================================================
// ================= Other Write Functions ================
// ========================================================
/**
*
* @param _upkeepId The ID of the upkeep to initialize the forwarder for
*/
function initializeForwarder(uint256 _upkeepId) external;
// ========================================================
// =================== Getter Functions ===================
// ========================================================
function heartbeat() external view returns (uint256);
function gracePeriod() external view returns (uint256);
function upperEdge() external view returns (uint256);
function lowerEdge() external view returns (uint256);
function chainlinkRegistry() external view returns (address);
function exchangeRateNumerator() external view returns (uint256);
function exchangeRateDenominator() external view returns (uint256);
function lastUpdateTimestamp() external view returns (uint256);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
/**
* @title IChainlinkAutomationRegistry
* @author Dolomite
*
*/
interface IChainlinkAutomationRegistry {
/**
*
*
* @param _upkeepId The ID of the upkeep to get the forwarder for
* @return The address of the Chainlink forwarder for the given job ID
*/
function getForwarder(uint256 _upkeepId) external view returns (address);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IDolomitePriceOracle } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomitePriceOracle.sol"; // solhint-disable-line max-line-length
import { IChainlinkAggregator } from "./IChainlinkAggregator.sol";
/**
* @title IChainlinkPriceOracleV1
* @author Dolomite
*
* An interface of IDolomitePriceOracle that makes Chainlink prices compatible with the protocol.
*/
interface IChainlinkPriceOracleV1 is IDolomitePriceOracle {
// ============ Events ============
event StalenessDurationUpdated(uint256 stalenessDuration);
event TokenInsertedOrUpdated(
address indexed token,
address indexed aggregator,
address indexed tokenPair
);
// ============ Admin Functions ============
/**
* @dev Sets the new `stalenessThreshold`. This function can only be called by the owner of DolomiteMargin.
*
* @param _stalenessThreshold The duration of time that must pass before a price is considered stale from a
* Chainlink Aggregator
*/
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external;
/**
* @dev Insert or update a token in the oracle. This function can only be called by the owner of DolomiteMargin.
*
* @param _token The token whose Chainlink aggregator should be inserted or updated
* @param _tokenDecimals The number of decimals that this token has
* @param _chainlinkAggregator The Chainlink aggregator that corresponds with this token
* @param _tokenPair The token pair that corresponds with this token. The zero address means USD.
*/
function ownerInsertOrUpdateOracleToken(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair
)
external;
// ============ Getter Functions ============
/**
*
* @param _token The token whose Chainlink aggregator should be retrieved
* @return The aggregator that corresponds with this token
*/
function getAggregatorByToken(address _token) external view returns (IChainlinkAggregator);
/**
*
* @param _token The token whose decimals should be retrieved
* @return The number of decimals that this token has
*/
function getDecimalsByToken(address _token) external view returns (uint8);
/**
*
* @param _token The token whose token pair should be retrieved
* @return _tokenPair The token pair that corresponds with this token. The zero address means USD.
*/
function getTokenPairByToken(address _token) external view returns (address _tokenPair);
/**
* @return The duration of time that must pass before a price is considered stale from a Chainlink Aggregator
*/
function stalenessThreshold() external view returns (uint256);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IDolomitePriceOracle } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomitePriceOracle.sol"; // solhint-disable-line max-line-length
import { IChainlinkAggregator } from "./IChainlinkAggregator.sol";
/**
* @title IChainlinkPriceOracleV2
* @author Dolomite
*
* An interface of IDolomitePriceOracle that makes Chainlink prices compatible with the protocol.
*/
interface IChainlinkPriceOracleV2 is IDolomitePriceOracle {
// ============ Events ============
event StalenessDurationUpdated(uint256 stalenessDuration);
event TokenInsertedOrUpdated(
address indexed token,
address indexed aggregator,
address indexed tokenPair
);
// ============ Admin Functions ============
/**
* @dev Sets the new `stalenessThreshold`. This function can only be called by the owner of DolomiteMargin.
*
* @param _stalenessThreshold The duration of time that must pass before a price is considered stale from a
* Chainlink Aggregator
*/
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external;
/**
* @dev Insert or update a token in the oracle. This function can only be called by the owner of DolomiteMargin.
*
* @param _token The token whose Chainlink aggregator should be inserted or updated
* @param _tokenDecimals The number of decimals that this token has
* @param _chainlinkAggregator The Chainlink aggregator that corresponds with this token
* @param _tokenPair The token pair that corresponds with this token. The zero address means USD.
* @param _bypassUsdValue True if the token does not return USD price
*/
function ownerInsertOrUpdateOracleTokenWithBypass(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair,
bool _bypassUsdValue
)
external;
/**
* @dev Insert or update a token in the oracle. This function can only be called by the owner of DolomiteMargin.
*
* @param _token The token whose Chainlink aggregator should be inserted or updated
* @param _tokenDecimals The number of decimals that this token has
* @param _chainlinkAggregator The Chainlink aggregator that corresponds with this token
* @param _tokenPair The token pair that corresponds with this token. The zero address means USD.
*/
function ownerInsertOrUpdateOracleToken(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair
)
external;
// ============ Getter Functions ============
/**
*
* @param _token The token whose Chainlink aggregator should be retrieved
* @return The aggregator that corresponds with this token
*/
function getAggregatorByToken(address _token) external view returns (IChainlinkAggregator);
/**
*
* @param _token The token whose decimals should be retrieved
* @return The number of decimals that this token has
*/
function getDecimalsByToken(address _token) external view returns (uint8);
/**
*
* @param _token The token whose token pair should be retrieved
* @return _tokenPair The token pair that corresponds with this token. The zero address means USD.
*/
function getTokenPairByToken(address _token) external view returns (address _tokenPair);
/**
* @return The duration of time that must pass before a price is considered stale from a Chainlink Aggregator
*/
function stalenessThreshold() external view returns (uint256);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IDolomitePriceOracle } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomitePriceOracle.sol"; // solhint-disable-line max-line-length
import { IChainlinkAggregator } from "./IChainlinkAggregator.sol";
/**
* @title IChainlinkPriceOracleV3
* @author Dolomite
*
* An interface of IDolomitePriceOracle that makes Chainlink prices compatible with the protocol.
*/
interface IChainlinkPriceOracleV3 is IDolomitePriceOracle {
// ============ Events ============
event StalenessDurationUpdated(uint256 stalenessDuration);
event TokenInsertedOrUpdated(
address indexed token,
address indexed aggregator
);
// ============ Admin Functions ============
/**
* @dev Sets the new `stalenessThreshold`. This function can only be called by the owner of DolomiteMargin.
*
* @param _stalenessThreshold The duration of time that must pass before a price is considered stale from a
* Chainlink Aggregator
*/
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external;
/**
* @dev Insert or update a token in the oracle. This function can only be called by the owner of DolomiteMargin.
*
* @param _token The token whose Chainlink aggregator should be inserted or updated
* @param _chainlinkAggregator The Chainlink aggregator that corresponds with this token
* @param _invertPrice True if should invert the price received from Chainlink
*/
function ownerInsertOrUpdateOracleToken(
address _token,
address _chainlinkAggregator,
bool _invertPrice
)
external;
// ============ Getter Functions ============
/**
*
* @param _token The token whose Chainlink aggregator should be retrieved
* @return The aggregator that corresponds with this token
*/
function getAggregatorByToken(address _token) external view returns (IChainlinkAggregator);
/**
*
* @param _token The token whose token pair should be retrieved
* @return _invertPrice True if should invert the price received from Chainlink
*/
function getInvertPriceByToken(address _token) external view returns (bool _invertPrice);
/**
* @return The duration of time that must pass before a price is considered stale from a Chainlink Aggregator
*/
function stalenessThreshold() external view returns (uint256);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IDolomitePriceOracle } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomitePriceOracle.sol"; // solhint-disable-line max-line-length
/**
* @title IOracleAggregatorV2
* @author Dolomite
*
* An interface of IDolomitePriceOracle that aggregates all oracles into one contract
*/
interface IOracleAggregatorV2 is IDolomitePriceOracle {
struct TokenInfo {
OracleInfo[] oracleInfos;
uint8 decimals;
address token;
}
struct OracleInfo {
address oracle;
address tokenPair;
uint256 weight;
}
// ============ Events ============
event TokenInsertedOrUpdated(
TokenInfo info
);
// ============ Admin Functions ============
/**
* @dev Insert or update a token in the oracle. This function can only be called by the owner of DolomiteMargin.
*
* @param _info The info for the token
*/
function ownerInsertOrUpdateToken(
TokenInfo memory _info
)
external;
// ============ Getter Functions ============
function getDecimalsByToken(address _token) external view returns (uint8);
function getTokenInfo(address _token) external view returns (TokenInfo memory);
function getOraclesByToken(address _token) external view returns (OracleInfo[] memory);
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
/**
* @title IPancakeV3Pair
* @author Dolomite
*
* @notice Interface for Algebra V3 pools
*/
interface IPancakeV3Pair {
function observe(
uint32[] calldata secondsAgo
)
external
view
returns (
int56[] memory tickCumulatives,
uint160[] memory secondsPerLiquidityCumulativeX128s
);
function getTimepoints(
uint32[] calldata secondsAgos
)
external
view
returns (
int56[] memory tickCumulatives,
uint160[] memory secondsPerLiquidityCumulatives,
uint112[] memory volatilityCumulatives,
uint256[] memory volumePerAvgLiquiditys
);
function token0() external view returns (address);
function token1() external view returns (address);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IDolomitePriceOracle } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomitePriceOracle.sol"; // solhint-disable-line max-line-length
import { IChainlinkAggregator } from "./IChainlinkAggregator.sol";
/**
* @title IRedstonePriceOracleV2
* @author Dolomite
*
* An interface of IDolomitePriceOracle that makes Redstone prices compatible with the protocol.
*/
interface IRedstonePriceOracleV2 is IDolomitePriceOracle {
// ============ Events ============
event StalenessDurationUpdated(uint256 stalenessDuration);
event TokenInsertedOrUpdated(
address indexed token,
address indexed aggregator,
address indexed tokenPair
);
// ============ Admin Functions ============
/**
* @dev Sets the new `stalenessThreshold`. This function can only be called by the owner of DolomiteMargin.
*
* @param _stalenessThreshold The duration of time that must pass before a price is considered stale from a
* Chainlink Aggregator
*/
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external;
/**
* @dev Insert or update a token in the oracle. This function can only be called by the owner of DolomiteMargin.
*
* @param _token The token whose Chainlink aggregator should be inserted or updated
* @param _tokenDecimals The number of decimals that this token has
* @param _chainlinkAggregator The Chainlink aggregator that corresponds with this token
* @param _tokenPair The token pair that corresponds with this token. The zero address means USD.
* @param _tokenToBypassUsdValue If true, the token does not return a USD value
*/
function ownerInsertOrUpdateOracleToken(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair,
bool _tokenToBypassUsdValue
)
external;
// ============ Getter Functions ============
/**
*
* @param _token The token whose Chainlink aggregator should be retrieved
* @return The aggregator that corresponds with this token
*/
function getAggregatorByToken(address _token) external view returns (IChainlinkAggregator);
/**
*
* @param _token The token whose decimals should be retrieved
* @return The number of decimals that this token has
*/
function getDecimalsByToken(address _token) external view returns (uint8);
/**
*
* @param _token The token whose token pair should be retrieved
* @return _tokenPair The token pair that corresponds with this token. The zero address means USD.
*/
function getTokenPairByToken(address _token) external view returns (address _tokenPair);
/**
* @return The duration of time that must pass before a price is considered stale from a Chainlink Aggregator
*/
function stalenessThreshold() external view returns (uint256);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IDolomitePriceOracle } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomitePriceOracle.sol"; // solhint-disable-line max-line-length
import { IChainlinkAggregator } from "./IChainlinkAggregator.sol";
/**
* @title IRedstonePriceOracleV3
* @author Dolomite
*
* An interface of IDolomitePriceOracle that makes Redstone prices compatible with the protocol.
*/
interface IRedstonePriceOracleV3 is IDolomitePriceOracle {
// ============ Events ============
event StalenessDurationUpdated(uint256 stalenessDuration);
event TokenInsertedOrUpdated(
address indexed token,
address indexed aggregator
);
// ============ Admin Functions ============
/**
* @dev Sets the new `stalenessThreshold`. This function can only be called by the owner of DolomiteMargin.
*
* @param _stalenessThreshold The duration of time that must pass before a price is considered stale from a
* Chainlink Aggregator
*/
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external;
/**
* @dev Insert or update a token in the oracle. This function can only be called by the owner of DolomiteMargin.
*
* @param _token The token whose Chainlink aggregator should be inserted or updated
* @param _chainlinkAggregator The Chainlink aggregator that corresponds with this token
* @param _invertPrice True if should invert the price received from Chainlink
*/
function ownerInsertOrUpdateOracleToken(
address _token,
address _chainlinkAggregator,
bool _invertPrice
)
external;
// ============ Getter Functions ============
/**
*
* @param _token The token whose Chainlink aggregator should be retrieved
* @return The aggregator that corresponds with this token
*/
function getAggregatorByToken(address _token) external view returns (IChainlinkAggregator);
/**
*
* @param _token The token whose token pair should be retrieved
* @return _invertPrice True if price from Chainlink should be inverted
*/
function getInvertPriceByToken(address _token) external view returns (bool _invertPrice);
/**
* @return The duration of time that must pass before a price is considered stale from a Chainlink Aggregator
*/
function stalenessThreshold() external view returns (uint256);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { IDolomitePriceOracle } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomitePriceOracle.sol"; // solhint-disable-line max-line-length
/**
* @title ITWAPPriceOracleV1
* @author Dolomite
*
* An interface of IDolomitePriceOracle that uses TWAP to get prices compatible with the protocol
*/
interface ITWAPPriceOracleV1 is IDolomitePriceOracle {
// ============ Events ============
event ObservationIntervalUpdated(uint256 observationInterval);
event PairAdded(address pair);
event PairRemoved(address pair);
// ============ Admin Functions ============
/**
* @dev Sets the new `stalenessThreshold`. This function can only be called by the owner of DolomiteMargin.
*
* @param _observationInterval The duration of time that must pass before a price is considered stale from a
* Chainlink Aggregator
*/
function ownerSetObservationInterval(
uint32 _observationInterval
)
external;
// ============ Getter Functions ============
/**
/**
* @return The duration of time that must pass before a price is considered stale from a Chainlink Aggregator
*/
function observationInterval() external view returns (uint32);
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomiteRegistry } from "@dolomite-exchange/modules-base/contracts/interfaces/IDolomiteRegistry.sol";
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IChainlinkAggregator } from "./interfaces/IChainlinkAggregator.sol";
import { IChainlinkPriceOracleV3 } from "./interfaces/IChainlinkPriceOracleV3.sol";
import { IOracleAggregatorV2 } from "./interfaces/IOracleAggregatorV2.sol";
/**
* @title OkxPriceOracleV3
* @author Dolomite
*
* An implementation of the IDolomitePriceOracle interface that makes OKX prices compatible with the protocol. This
* implementation is meant to be tied to OracleAggregator.
*
* For more information, visit https://www.okx.com/xlayer/docs/developer/oracle/price-feed
*/
contract OkxPriceOracleV3 is IChainlinkPriceOracleV3, OnlyDolomiteMargin {
// ========================= Constants =========================
bytes32 private constant _FILE = "OkxPriceOracleV3";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
// ========================= Storage =========================
mapping(address => IChainlinkAggregator) private _tokenToAggregatorMap;
mapping(address => bool) private _tokenToInvertPriceMap;
IDolomiteRegistry public immutable DOLOMITE_REGISTRY;
uint256 public stalenessThreshold;
// ========================= Constructor =========================
/**
* Note, these arrays are set up such that each index corresponds with one-another.
*
* @param _tokens The tokens that are supported by this adapter.
* @param _chainlinkAggregators The Chainlink aggregators that have on-chain prices.
* @param _invertPrice True if should invert price received from Chainlink
* @param _dolomiteRegistry The address of the DolomiteRegistry contract.
* @param _dolomiteMargin The address of the DolomiteMargin contract.
*/
constructor(
address[] memory _tokens,
address[] memory _chainlinkAggregators,
bool[] memory _invertPrice,
address _dolomiteRegistry,
address _dolomiteMargin
)
OnlyDolomiteMargin(_dolomiteMargin)
{
Require.that(
_tokens.length == _chainlinkAggregators.length,
_FILE,
"Invalid tokens length"
);
Require.that(
_chainlinkAggregators.length == _invertPrice.length,
_FILE,
"Invalid aggregators length"
);
uint256 tokensLength = _tokens.length;
for (uint256 i; i < tokensLength; ++i) {
_ownerInsertOrUpdateOracleToken(
_tokens[i],
_chainlinkAggregators[i],
_invertPrice[i]
);
}
_ownerSetStalenessThreshold(36 hours);
DOLOMITE_REGISTRY = IDolomiteRegistry(_dolomiteRegistry);
}
// ========================= Admin Functions =========================
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerSetStalenessThreshold(_stalenessThreshold);
}
function ownerInsertOrUpdateOracleToken(
address _token,
address _chainlinkAggregator,
bool _invertPrice
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerInsertOrUpdateOracleToken(
_token,
_chainlinkAggregator,
_invertPrice
);
}
// ========================= Public Functions =========================
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory)
{
Require.that(
address(_tokenToAggregatorMap[_token]) != address(0),
_FILE,
"Invalid token",
_token
);
Require.that(
msg.sender != address(DOLOMITE_MARGIN()),
_FILE,
"DolomiteMargin cannot call"
);
IChainlinkAggregator aggregatorProxy = _tokenToAggregatorMap[_token];
(
/* uint80 roundId */,
int256 answer,
/* uint256 startedAt */,
uint256 updatedAt,
/* uint80 answeredInRound */
) = aggregatorProxy.latestRoundData();
Require.that(
block.timestamp - updatedAt < stalenessThreshold,
_FILE,
"OKX price expired",
_token,
updatedAt
);
uint256 okxPrice = uint256(answer);
uint8 valueDecimals = aggregatorProxy.decimals();
if (_tokenToInvertPriceMap[_token]) {
uint256 decimalFactor = 10 ** uint256(valueDecimals);
okxPrice = (decimalFactor ** 2) / okxPrice;
}
// standardize the OKX price to be the proper number of decimals of (36 - tokenDecimals)
IOracleAggregatorV2 aggregator = IOracleAggregatorV2(address(DOLOMITE_REGISTRY.oracleAggregator()));
uint8 tokenDecimals = aggregator.getDecimalsByToken(_token);
assert(tokenDecimals > 0);
uint256 standardizedPrice = standardizeNumberOfDecimals(
tokenDecimals,
okxPrice,
valueDecimals
);
return IDolomiteStructs.MonetaryPrice({
value: standardizedPrice
});
}
function getAggregatorByToken(address _token) public view returns (IChainlinkAggregator) {
return _tokenToAggregatorMap[_token];
}
function getInvertPriceByToken(address _token) public view returns (bool _invertPrice) {
return _tokenToInvertPriceMap[_token];
}
/**
* Standardizes `value` to have `ONE_DOLLAR.decimals` - `tokenDecimals` number of decimals.
*/
function standardizeNumberOfDecimals(
uint8 _tokenDecimals,
uint256 _value,
uint8 _valueDecimals
)
public
pure
returns (uint)
{
uint256 tokenDecimalsFactor = 10 ** uint256(_tokenDecimals);
uint256 priceFactor = _ONE_DOLLAR / tokenDecimalsFactor;
uint256 valueFactor = 10 ** uint256(_valueDecimals);
return _value * priceFactor / valueFactor;
}
// ========================= Internal Functions =========================
function _ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
internal
{
Require.that(
_stalenessThreshold >= 24 hours,
_FILE,
"Staleness threshold too low",
_stalenessThreshold
);
Require.that(
_stalenessThreshold <= 7 days,
_FILE,
"Staleness threshold too high",
_stalenessThreshold
);
stalenessThreshold = _stalenessThreshold;
emit StalenessDurationUpdated(_stalenessThreshold);
}
function _ownerInsertOrUpdateOracleToken(
address _token,
address _chainlinkAggregator,
bool _invertPrice
) internal {
_tokenToAggregatorMap[_token] = IChainlinkAggregator(_chainlinkAggregator);
_tokenToInvertPriceMap[_token] = _invertPrice;
emit TokenInsertedOrUpdated(_token, _chainlinkAggregator);
}
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomiteRegistry } from "@dolomite-exchange/modules-base/contracts/interfaces/IDolomiteRegistry.sol";
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { IAlgebraV3Pool } from "./interfaces/IAlgebraV3Pool.sol";
import { IOracleAggregatorV2 } from "./interfaces/IOracleAggregatorV2.sol";
import { ITWAPPriceOracleV1 } from "./interfaces/ITWAPPriceOracleV1.sol";
import { OracleLibrary } from "./utils/OracleLibrary.sol";
/**
* @title PancakeV3PriceOracle
* @author Dolomite
*
* An implementation of the ITWAPPriceOracleV1.sol interface that makes gets the TWAP from an LP pool
*/
contract PancakeV3PriceOracle is ITWAPPriceOracleV1, OnlyDolomiteMargin {
using EnumerableSet for EnumerableSet.AddressSet;
// ========================= Constants =========================
bytes32 private constant _FILE = "PancakeV3PriceOracle";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
uint8 private constant _ORACLE_VALUE_DECIMALS = 36;
// ========================= Storage =========================
uint32 public observationInterval;
address public immutable TOKEN; // solhint-disable-line var-name-mixedcase
address public immutable PAIR;
uint256 public immutable TOKEN_DECIMALS_FACTOR; // solhint-disable-line var-name-mixedcase
IDolomiteRegistry public immutable DOLOMITE_REGISTRY;
// ========================= Constructor =========================
constructor(
address _token,
address _pair,
address _dolomiteRegistry,
address _dolomiteMargin
) OnlyDolomiteMargin(_dolomiteMargin) {
TOKEN = _token;
PAIR = _pair;
_ownerSetObservationInterval(15 minutes);
TOKEN_DECIMALS_FACTOR = 10 ** IERC20Metadata(_token).decimals();
DOLOMITE_REGISTRY = IDolomiteRegistry(_dolomiteRegistry);
}
// ========================= Admin Functions =========================
function ownerSetObservationInterval(
uint32 _observationInterval
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerSetObservationInterval(_observationInterval);
}
// ========================= Public Functions =========================
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory) {
Require.that(
_token == TOKEN,
_FILE,
"Invalid token",
_token
);
IAlgebraV3Pool currentPair = IAlgebraV3Pool(PAIR);
address poolToken0 = currentPair.token0();
address outputToken = poolToken0 == _token ? currentPair.token1() : poolToken0;
int24 tick = OracleLibrary.consultPancakeSwap(address(currentPair), observationInterval);
uint256 quote = OracleLibrary.getQuoteAtTick(tick, uint128(TOKEN_DECIMALS_FACTOR), _token, outputToken);
IOracleAggregatorV2 aggregator = IOracleAggregatorV2(address(DOLOMITE_REGISTRY.oracleAggregator()));
uint8 outputTokenDecimals = aggregator.getDecimalsByToken(outputToken);
assert(outputTokenDecimals > 0);
// @follow-up Is this standardization correct here? Also in the TWAP oracle
return IDolomiteStructs.MonetaryPrice({
value: _standardizeNumberOfDecimals(quote, outputTokenDecimals)
});
}
// ========================= Internal Functions =========================
function _ownerSetObservationInterval(
uint32 _observationInterval
)
internal {
observationInterval = _observationInterval;
emit ObservationIntervalUpdated(_observationInterval);
}
function _standardizeNumberOfDecimals(
uint256 _value,
uint8 _valueDecimals
) internal view returns (uint) {
uint256 priceFactor = _ONE_DOLLAR / TOKEN_DECIMALS_FACTOR;
uint256 valueFactor = 10 ** uint256(_valueDecimals);
return _value * priceFactor / valueFactor;
}
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IChainlinkAggregator } from "./interfaces/IChainlinkAggregator.sol";
import { IRedstonePriceOracleV2 } from "./interfaces/IRedstonePriceOracleV2.sol";
/**
* @title RedstonePriceOracleV2
* @author Dolomite
* @dev Redstone oracles have the same interface as Chainlink oracles
*
* An implementation of the IDolomitePriceOracle interface that makes Redstone prices compatible with the protocol.
*/
contract RedstonePriceOracleV2 is IRedstonePriceOracleV2, OnlyDolomiteMargin {
// ========================= Constants =========================
bytes32 private constant _FILE = "RedstonePriceOracleV2";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
// ========================= Storage =========================
mapping(address => IChainlinkAggregator) private _tokenToAggregatorMap;
mapping(address => uint8) private _tokenToDecimalsMap;
/// @dev Defaults to USD if the value is the ZERO address
mapping(address => address) private _tokenToPairingMap;
mapping(address => bool) private _tokenToBypassUsdValueMap;
uint256 public stalenessThreshold;
// ========================= Constructor =========================
/**
* Note, these arrays are set up such that each index corresponds with one-another.
*
* @param _tokens The tokens that are supported by this adapter.
* @param _chainlinkAggregators The Chainlink aggregators that have on-chain prices.
* @param _tokenDecimals The number of decimals that each token has.
* @param _tokenPairs The token against which this token's value is compared using the aggregator. The
* zero address means USD.
* @param _tokenToBypassUsdValue True if the token does NOT return a USD value
* @param _dolomiteMargin The address of the DolomiteMargin contract.
*/
constructor(
address[] memory _tokens,
address[] memory _chainlinkAggregators,
uint8[] memory _tokenDecimals,
address[] memory _tokenPairs,
bool[] memory _tokenToBypassUsdValue,
address _dolomiteMargin
)
OnlyDolomiteMargin(_dolomiteMargin)
{
Require.that(
_tokens.length == _chainlinkAggregators.length,
_FILE,
"Invalid tokens length"
);
Require.that(
_chainlinkAggregators.length == _tokenDecimals.length,
_FILE,
"Invalid aggregators length"
);
Require.that(
_tokenDecimals.length == _tokenPairs.length,
_FILE,
"Invalid decimals length"
);
Require.that(
_tokenPairs.length == _tokenToBypassUsdValue.length,
_FILE,
"Invalid pairs length"
);
uint256 tokensLength = _tokens.length;
for (uint256 i; i < tokensLength; ++i) {
_ownerInsertOrUpdateOracleToken(
_tokens[i],
_tokenDecimals[i],
_chainlinkAggregators[i],
_tokenPairs[i],
_tokenToBypassUsdValue[i]
);
}
_ownerSetStalenessThreshold(36 hours);
}
// ========================= Admin Functions =========================
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerSetStalenessThreshold(_stalenessThreshold);
}
function ownerInsertOrUpdateOracleToken(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair,
bool _tokenToBypassUsdValue
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerInsertOrUpdateOracleToken(
_token,
_tokenDecimals,
_chainlinkAggregator,
_tokenPair,
_tokenToBypassUsdValue
);
}
// ========================= Public Functions =========================
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory)
{
Require.that(
address(_tokenToAggregatorMap[_token]) != address(0),
_FILE,
"Invalid token",
_token
);
if (_tokenToBypassUsdValueMap[_token]) {
Require.that(
msg.sender != address(DOLOMITE_MARGIN()),
_FILE,
"Token bypasses USD value",
_token
);
}
IChainlinkAggregator aggregatorProxy = _tokenToAggregatorMap[_token];
(
/* uint80 roundId */,
int256 answer,
/* uint256 startedAt */,
uint256 updatedAt,
/* uint80 answeredInRound */
) = aggregatorProxy.latestRoundData();
Require.that(
block.timestamp - updatedAt < stalenessThreshold,
_FILE,
"Chainlink price expired",
_token
);
uint256 chainlinkPrice = uint256(answer);
address tokenPair = _tokenToPairingMap[_token];
// standardize the Chainlink price to be the proper number of decimals of (36 - tokenDecimals)
uint256 standardizedPrice = standardizeNumberOfDecimals(
_tokenToDecimalsMap[_token],
chainlinkPrice,
aggregatorProxy.decimals()
);
if (tokenPair == address(0)) {
// The pair has a USD base, we are done.
return IDolomiteStructs.MonetaryPrice({
value: standardizedPrice
});
} else {
// The price we just got and converted is NOT against USD. So we need to get its pair's price against USD.
// We can do so by recursively calling #getPrice using the `tokenPair` as the parameter instead of `token`.
uint256 tokenPairPrice;
if (address(_tokenToAggregatorMap[tokenPair]) == address(0)) {
uint256 marketId = DOLOMITE_MARGIN().getMarketIdByTokenAddress(tokenPair);
tokenPairPrice = DOLOMITE_MARGIN().getMarketPrice(marketId).value;
} else {
tokenPairPrice = getPrice(tokenPair).value;
}
// Standardize the price to use 36 decimals.
uint256 tokenPairWith36Decimals = tokenPairPrice * (10 ** uint256(_tokenToDecimalsMap[tokenPair]));
// Now that the chained price uses 36 decimals (and thus is standardized), we can do easy math.
return IDolomiteStructs.MonetaryPrice({
value: standardizedPrice * tokenPairWith36Decimals / _ONE_DOLLAR
});
}
}
function getAggregatorByToken(address _token) public view returns (IChainlinkAggregator) {
return _tokenToAggregatorMap[_token];
}
function getDecimalsByToken(address _token) public view returns (uint8) {
return _tokenToDecimalsMap[_token];
}
function getTokenPairByToken(address _token) public view returns (address _tokenPair) {
return _tokenToPairingMap[_token];
}
/**
* Standardizes `value` to have `ONE_DOLLAR.decimals` - `tokenDecimals` number of decimals.
*/
function standardizeNumberOfDecimals(
uint8 _tokenDecimals,
uint256 _value,
uint8 _valueDecimals
)
public
pure
returns (uint)
{
uint256 tokenDecimalsFactor = 10 ** uint256(_tokenDecimals);
uint256 priceFactor = _ONE_DOLLAR / tokenDecimalsFactor;
uint256 valueFactor = 10 ** uint256(_valueDecimals);
return _value * priceFactor / valueFactor;
}
// ========================= Internal Functions =========================
function _ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
internal
{
Require.that(
_stalenessThreshold >= 24 hours,
_FILE,
"Staleness threshold too low",
_stalenessThreshold
);
Require.that(
_stalenessThreshold <= 7 days,
_FILE,
"Staleness threshold too high",
_stalenessThreshold
);
stalenessThreshold = _stalenessThreshold;
emit StalenessDurationUpdated(_stalenessThreshold);
}
function _ownerInsertOrUpdateOracleToken(
address _token,
uint8 _tokenDecimals,
address _chainlinkAggregator,
address _tokenPair,
bool _tokenToBypassUsdValue
) internal {
_tokenToAggregatorMap[_token] = IChainlinkAggregator(_chainlinkAggregator);
_tokenToDecimalsMap[_token] = _tokenDecimals;
_tokenToBypassUsdValueMap[_token] = _tokenToBypassUsdValue;
if (_tokenPair != address(0)) {
_tokenToPairingMap[_token] = _tokenPair;
}
emit TokenInsertedOrUpdated(_token, _chainlinkAggregator, _tokenPair);
}
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomiteRegistry } from "@dolomite-exchange/modules-base/contracts/interfaces/IDolomiteRegistry.sol";
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IChainlinkAggregator } from "./interfaces/IChainlinkAggregator.sol";
import { IOracleAggregatorV2 } from "./interfaces/IOracleAggregatorV2.sol";
import { IRedstonePriceOracleV3 } from "./interfaces/IRedstonePriceOracleV3.sol";
/**
* @title RedstonePriceOracleV3
* @author Dolomite
* @dev Redstone oracles have the same interface as Chainlink oracles
*
* An implementation of the IDolomitePriceOracle interface that makes Redstone prices compatible with oracle aggregator
*/
contract RedstonePriceOracleV3 is IRedstonePriceOracleV3, OnlyDolomiteMargin {
// ========================= Constants =========================
bytes32 private constant _FILE = "RedstonePriceOracleV3";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
// ========================= Storage =========================
mapping(address => IChainlinkAggregator) private _tokenToAggregatorMap;
mapping(address => bool) private _tokenToInvertPriceMap;
IDolomiteRegistry public immutable DOLOMITE_REGISTRY;
uint256 public stalenessThreshold;
// ========================= Constructor =========================
/**
* Note, these arrays are set up such that each index corresponds with one-another.
*
* @param _tokens The tokens that are supported by this adapter.
* @param _chainlinkAggregators The Chainlink aggregators that have on-chain prices.
* @param _invertPrice True if should invert price received from Chainlink
* @param _dolomiteMargin The address of the DolomiteMargin contract.
*/
constructor(
address[] memory _tokens,
address[] memory _chainlinkAggregators,
bool[] memory _invertPrice,
address _dolomiteRegistry,
address _dolomiteMargin
)
OnlyDolomiteMargin(_dolomiteMargin)
{
Require.that(
_tokens.length == _chainlinkAggregators.length,
_FILE,
"Invalid tokens length"
);
Require.that(
_chainlinkAggregators.length == _invertPrice.length,
_FILE,
"Invalid aggregators length"
);
uint256 tokensLength = _tokens.length;
for (uint256 i; i < tokensLength; ++i) {
_ownerInsertOrUpdateOracleToken(
_tokens[i],
_chainlinkAggregators[i],
_invertPrice[i]
);
}
_ownerSetStalenessThreshold(36 hours);
DOLOMITE_REGISTRY = IDolomiteRegistry(_dolomiteRegistry);
}
// ========================= Admin Functions =========================
function ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerSetStalenessThreshold(_stalenessThreshold);
}
function ownerInsertOrUpdateOracleToken(
address _token,
address _chainlinkAggregator,
bool _invertPrice
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerInsertOrUpdateOracleToken(
_token,
_chainlinkAggregator,
_invertPrice
);
}
// ========================= Public Functions =========================
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory)
{
Require.that(
address(_tokenToAggregatorMap[_token]) != address(0),
_FILE,
"Invalid token",
_token
);
Require.that(
msg.sender != address(DOLOMITE_MARGIN()),
_FILE,
"DolomiteMargin cannot call"
);
IChainlinkAggregator aggregatorProxy = _tokenToAggregatorMap[_token];
(
/* uint80 roundId */,
int256 answer,
/* uint256 startedAt */,
uint256 updatedAt,
/* uint80 answeredInRound */
) = aggregatorProxy.latestRoundData();
Require.that(
block.timestamp - updatedAt < stalenessThreshold,
_FILE,
"Chainlink price expired",
_token
);
uint256 chainlinkPrice = uint256(answer);
uint8 valueDecimals = aggregatorProxy.decimals();
if (_tokenToInvertPriceMap[_token]) {
uint256 decimalFactor = 10 ** uint256(valueDecimals);
chainlinkPrice = (decimalFactor ** 2) / chainlinkPrice;
}
// standardize the Chainlink price to be the proper number of decimals of (36 - tokenDecimals)
IOracleAggregatorV2 aggregator = IOracleAggregatorV2(address(DOLOMITE_REGISTRY.oracleAggregator()));
uint8 tokenDecimals = aggregator.getDecimalsByToken(_token);
assert(tokenDecimals > 0);
uint256 standardizedPrice = standardizeNumberOfDecimals(
tokenDecimals,
chainlinkPrice,
valueDecimals
);
return IDolomiteStructs.MonetaryPrice({
value: standardizedPrice
});
}
function getAggregatorByToken(address _token) public view returns (IChainlinkAggregator) {
return _tokenToAggregatorMap[_token];
}
function getInvertPriceByToken(address _token) public view returns (bool _invertPrice) {
return _tokenToInvertPriceMap[_token];
}
/**
* Standardizes `value` to have `ONE_DOLLAR.decimals` - `tokenDecimals` number of decimals.
*/
function standardizeNumberOfDecimals(
uint8 _tokenDecimals,
uint256 _value,
uint8 _valueDecimals
)
public
pure
returns (uint)
{
uint256 tokenDecimalsFactor = 10 ** uint256(_tokenDecimals);
uint256 priceFactor = _ONE_DOLLAR / tokenDecimalsFactor;
uint256 valueFactor = 10 ** uint256(_valueDecimals);
return _value * priceFactor / valueFactor;
}
// ========================= Internal Functions =========================
function _ownerSetStalenessThreshold(
uint256 _stalenessThreshold
)
internal
{
Require.that(
_stalenessThreshold >= 24 hours,
_FILE,
"Staleness threshold too low",
_stalenessThreshold
);
Require.that(
_stalenessThreshold <= 7 days,
_FILE,
"Staleness threshold too high",
_stalenessThreshold
);
stalenessThreshold = _stalenessThreshold;
emit StalenessDurationUpdated(_stalenessThreshold);
}
function _ownerInsertOrUpdateOracleToken(
address _token,
address _chainlinkAggregator,
bool _invertPrice
) internal {
_tokenToAggregatorMap[_token] = IChainlinkAggregator(_chainlinkAggregator);
_tokenToInvertPriceMap[_token] = _invertPrice;
emit TokenInsertedOrUpdated(_token, _chainlinkAggregator);
}
}// SPDX-License-Identifier: GPL-3.0-or-later
/*
Copyright 2023 Dolomite
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
pragma solidity ^0.8.9;
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { ICustomTestVaultToken } from "@dolomite-exchange/modules-base/contracts/test/ICustomTestVaultToken.sol";
import { ChainlinkAutomationPriceOracle } from "../ChainlinkAutomationPriceOracle.sol";
/**
* @title TestChainlinkAutomationPriceOracle
* @author Dolomite
*
* @notice This contract is used to test the ChainlinkAutomationPriceOracle.sol contract.
*/
contract TestChainlinkAutomationPriceOracle is ChainlinkAutomationPriceOracle {
ICustomTestVaultToken public TOKEN; // solhint-disable-line var-name-mixedcase
uint256 public MARKET_ID; // solhint-disable-line var-name-mixedcase
constructor(
address _dolomiteMargin,
address _chainlinkRegistry,
address _token,
uint256 _marketId
) ChainlinkAutomationPriceOracle(_dolomiteMargin, _chainlinkRegistry) {
TOKEN = ICustomTestVaultToken(_token);
MARKET_ID = _marketId;
_updateExchangeRateAndTimestamp();
}
function getPrice(address /* _token */) external view returns (IDolomiteStructs.MonetaryPrice memory) {
_checkIsPriceExpired();
return IDolomiteStructs.MonetaryPrice({
value: _getCurrentPrice()
});
}
function _getExchangeRate() internal override view returns (uint256, uint256) {
return (TOKEN.totalAssets(), TOKEN.totalSupply());
}
function _getCurrentPrice() internal override view returns (uint256) {
return DOLOMITE_MARGIN().getMarketPrice(MARKET_ID).value;
}
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { IAlgebraV3Pool } from "./interfaces/IAlgebraV3Pool.sol";
import { ITWAPPriceOracleV1 } from "./interfaces/ITWAPPriceOracleV1.sol";
import { OracleLibrary } from "./utils/OracleLibrary.sol";
/**
* @title TWAPPriceOracleV1
* @author Dolomite
*
* An implementation of the ITWAPPriceOracleV1.sol interface that makes gets the TWAP from a number of LP pools
*/
contract TWAPPriceOracleV1 is ITWAPPriceOracleV1, OnlyDolomiteMargin {
using EnumerableSet for EnumerableSet.AddressSet;
// ========================= Constants =========================
bytes32 private constant _FILE = "TWAPPriceOracleV1";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
uint8 private constant _ORACLE_VALUE_DECIMALS = 36;
// ========================= Storage =========================
EnumerableSet.AddressSet private _pairs;
uint32 public observationInterval;
address public immutable TOKEN; // solhint-disable-line var-name-mixedcase
uint256 public immutable TOKEN_DECIMALS_FACTOR; // solhint-disable-line var-name-mixedcase
// ========================= Constructor =========================
constructor(
address _token,
address[] memory _tokenPairs,
address _dolomiteMargin
) OnlyDolomiteMargin(_dolomiteMargin) {
TOKEN = _token;
for (uint256 i; i < _tokenPairs.length; ++i) {
_ownerAddPair(_tokenPairs[i]);
}
_ownerSetObservationInterval(15 minutes);
TOKEN_DECIMALS_FACTOR = 10 ** IERC20Metadata(_token).decimals();
}
// ========================= Admin Functions =========================
function ownerSetObservationInterval(
uint32 _observationInterval
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerSetObservationInterval(_observationInterval);
}
function ownerAddPair(
address _pair
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerAddPair(_pair);
}
function ownerRemovePair(
address _pairAddress
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerRemovePair(_pairAddress);
}
// ========================= Public Functions =========================
function getPairs() external view returns (address[] memory) {
return _pairs.values();
}
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory) {
uint256 len = _pairs.length();
Require.that(
_token == TOKEN,
_FILE,
"Invalid token",
_token
);
Require.that(
len > 0,
_FILE,
"Oracle contains no pairs"
);
uint256 totalPrice;
for (uint256 i; i < len; ++i) {
IAlgebraV3Pool currentPair = IAlgebraV3Pool(_pairs.at(i));
address poolToken0 = currentPair.token0();
address outputToken = poolToken0 == _token ? currentPair.token1() : poolToken0;
int24 tick = OracleLibrary.consult(address(currentPair), observationInterval);
uint256 quote = OracleLibrary.getQuoteAtTick(tick, uint128(TOKEN_DECIMALS_FACTOR), _token, outputToken);
IDolomiteStructs.MonetaryPrice memory price =
DOLOMITE_MARGIN().getMarketPrice(DOLOMITE_MARGIN().getMarketIdByTokenAddress(outputToken));
totalPrice += _standardizeNumberOfDecimals(price.value * quote, _ORACLE_VALUE_DECIMALS);
}
return IDolomiteStructs.MonetaryPrice({
value: totalPrice / len
});
}
// ========================= Internal Functions =========================
function _ownerAddPair(
address _pair
)
internal {
IAlgebraV3Pool pool = IAlgebraV3Pool(_pair);
Require.that(
pool.token0() == TOKEN || pool.token1() == TOKEN,
_FILE,
"Pair must contain oracle token"
);
_pairs.add(_pair);
emit PairAdded(_pair);
}
function _ownerRemovePair(
address _pairAddress
)
internal {
_pairs.remove(_pairAddress);
emit PairRemoved(_pairAddress);
}
function _ownerSetObservationInterval(
uint32 _observationInterval
)
internal {
observationInterval = _observationInterval;
emit ObservationIntervalUpdated(_observationInterval);
}
function _standardizeNumberOfDecimals(
uint256 _value,
uint8 _valueDecimals
) internal view returns (uint) {
uint256 priceFactor = _ONE_DOLLAR / TOKEN_DECIMALS_FACTOR;
uint256 valueFactor = 10 ** uint256(_valueDecimals);
return _value * priceFactor / valueFactor;
}
}// SPDX-License-Identifier: Apache-2.0
/*
Copyright 2023 Dolomite.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.8.9;
import { OnlyDolomiteMargin } from "@dolomite-exchange/modules-base/contracts/helpers/OnlyDolomiteMargin.sol";
import { IDolomiteRegistry } from "@dolomite-exchange/modules-base/contracts/interfaces/IDolomiteRegistry.sol";
import { IDolomiteStructs } from "@dolomite-exchange/modules-base/contracts/protocol/interfaces/IDolomiteStructs.sol";
import { Require } from "@dolomite-exchange/modules-base/contracts/protocol/lib/Require.sol";
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { IAlgebraV3Pool } from "./interfaces/IAlgebraV3Pool.sol";
import { IOracleAggregatorV2 } from "./interfaces/IOracleAggregatorV2.sol";
import { ITWAPPriceOracleV1 } from "./interfaces/ITWAPPriceOracleV1.sol";
import { OracleLibrary } from "./utils/OracleLibrary.sol";
/**
* @title TWAPPriceOracleV2
* @author Dolomite
*
* An implementation of the ITWAPPriceOracleV1.sol interface that makes gets the TWAP from a number of LP pools
*/
contract TWAPPriceOracleV2 is ITWAPPriceOracleV1, OnlyDolomiteMargin {
// ========================= Constants =========================
bytes32 private constant _FILE = "TWAPPriceOracleV2";
uint256 private constant _ONE_DOLLAR = 10 ** 36;
// ========================= Storage =========================
uint32 public observationInterval;
address public immutable TOKEN; // solhint-disable-line var-name-mixedcase
address public immutable PAIR;
uint256 public immutable TOKEN_DECIMALS_FACTOR; // solhint-disable-line var-name-mixedcase
IDolomiteRegistry public immutable DOLOMITE_REGISTRY;
// ========================= Constructor =========================
constructor(
address _token,
address _pair,
address _dolomiteRegistry,
address _dolomiteMargin
) OnlyDolomiteMargin(_dolomiteMargin) {
TOKEN = _token;
PAIR = _pair;
_ownerSetObservationInterval(15 minutes);
TOKEN_DECIMALS_FACTOR = 10 ** IERC20Metadata(_token).decimals();
DOLOMITE_REGISTRY = IDolomiteRegistry(_dolomiteRegistry);
}
// ========================= Admin Functions =========================
function ownerSetObservationInterval(
uint32 _observationInterval
)
external
onlyDolomiteMarginOwner(msg.sender)
{
_ownerSetObservationInterval(_observationInterval);
}
// ========================= Public Functions =========================
function getPrice(
address _token
)
public
view
returns (IDolomiteStructs.MonetaryPrice memory) {
Require.that(
_token == TOKEN,
_FILE,
"Invalid token",
_token
);
IAlgebraV3Pool currentPair = IAlgebraV3Pool(PAIR);
address poolToken0 = currentPair.token0();
address outputToken = poolToken0 == _token ? currentPair.token1() : poolToken0;
int24 tick = OracleLibrary.consult(address(currentPair), observationInterval);
uint256 quote = OracleLibrary.getQuoteAtTick(tick, uint128(TOKEN_DECIMALS_FACTOR), _token, outputToken);
IOracleAggregatorV2 aggregator = IOracleAggregatorV2(address(DOLOMITE_REGISTRY.oracleAggregator()));
uint8 outputTokenDecimals = aggregator.getDecimalsByToken(outputToken);
assert(outputTokenDecimals > 0);
return IDolomiteStructs.MonetaryPrice({
value: _standardizeNumberOfDecimals(quote, outputTokenDecimals)
});
}
// ========================= Internal Functions =========================
function _ownerSetObservationInterval(
uint32 _observationInterval
)
internal {
observationInterval = _observationInterval;
emit ObservationIntervalUpdated(_observationInterval);
}
function _standardizeNumberOfDecimals(
uint256 _value,
uint8 _valueDecimals
) internal view returns (uint) {
uint256 priceFactor = _ONE_DOLLAR / TOKEN_DECIMALS_FACTOR;
uint256 valueFactor = 10 ** uint256(_valueDecimals);
return _value * priceFactor / valueFactor;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
// solhint-disable
/**
* @title FullMath
*
* @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision
* @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits
*/
library FullMath {
/// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
/// @param a The multiplicand
/// @param b The multiplier
/// @param denominator The divisor
/// @return result The 256-bit result
/// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv
function mulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = a * b
// Compute the product mod 2**256 and mod 2**256 - 1
// then use the Chinese Remainder Theorem to reconstruct
// the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2**256 + prod0
uint256 prod0 = a * b; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(a, b, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Make sure the result is less than 2**256.
// Also prevents denominator == 0
require(denominator > prod1);
// Handle non-overflow cases, 256 by 256 division
if (prod1 == 0) {
assembly {
result := div(prod0, denominator)
}
return result;
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0]
// Compute remainder using mulmod
uint256 remainder;
assembly {
remainder := mulmod(a, b, denominator)
}
// Subtract 256 bit number from 512 bit number
assembly {
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator
// Compute largest power of two divisor of denominator.
// Always >= 1.
uint256 twos = (0 - denominator) & denominator;
// Divide denominator by power of two
assembly {
denominator := div(denominator, twos)
}
// Divide [prod1 prod0] by the factors of two
assembly {
prod0 := div(prod0, twos)
}
// Shift in bits from prod1 into prod0. For this we need
// to flip `twos` such that it is 2**256 / twos.
// If twos is zero, then it becomes one
assembly {
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
// Invert denominator mod 2**256
// Now that denominator is an odd number, it has an inverse
// modulo 2**256 such that denominator * inv = 1 mod 2**256.
// Compute the inverse by starting with a seed that is correct
// correct for four bits. That is, denominator * inv = 1 mod 2**4
uint256 inv = (3 * denominator) ^ 2;
// Now use Newton-Raphson iteration to improve the precision.
// Thanks to Hensel's lifting lemma, this also works in modular
// arithmetic, doubling the correct bits in each step.
inv *= 2 - denominator * inv; // inverse mod 2**8
inv *= 2 - denominator * inv; // inverse mod 2**16
inv *= 2 - denominator * inv; // inverse mod 2**32
inv *= 2 - denominator * inv; // inverse mod 2**64
inv *= 2 - denominator * inv; // inverse mod 2**128
inv *= 2 - denominator * inv; // inverse mod 2**256
// Because the division is now exact we can divide by multiplying
// with the modular inverse of denominator. This will give us the
// correct result modulo 2**256. Since the preconditions guarantee
// that the outcome is less than 2**256, this is the final result.
// We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inv;
return result;
}
}
/// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
/// @param a The multiplicand
/// @param b The multiplier
/// @param denominator The divisor
/// @return result The 256-bit result
function mulDivRoundingUp(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
result = mulDiv(a, b, denominator);
if (mulmod(a, b, denominator) > 0) {
require(result < type(uint256).max);
result++;
}
}
}
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.9;
// solhint-disable
/**
* @title IAlgebraPoolErrors
*
* @notice Contains custom errors emitted by the pool
* @dev Custom errors are separated from the common pool interface for compatibility with older versions of Solidity
*/
interface IAlgebraPoolErrors {
// #### pool errors ####
/// @notice Emitted by the reentrancy guard
error locked();
/// @notice Emitted if arithmetic error occurred
error arithmeticError();
/// @notice Emitted if an attempt is made to initialize the pool twice
error alreadyInitialized();
/// @notice Emitted if an attempt is made to mint or swap in uninitialized pool
error notInitialized();
/// @notice Emitted if 0 is passed as amountRequired to swap function
error zeroAmountRequired();
/// @notice Emitted if invalid amount is passed as amountRequired to swap function
error invalidAmountRequired();
/// @notice Emitted if the pool received fewer tokens than it should have
error insufficientInputAmount();
/// @notice Emitted if there was an attempt to mint zero liquidity
error zeroLiquidityDesired();
/// @notice Emitted if actual amount of liquidity is zero (due to insufficient amount of tokens received)
error zeroLiquidityActual();
/// @notice Emitted if the pool received fewer tokens0 after flash than it should have
error flashInsufficientPaid0();
/// @notice Emitted if the pool received fewer tokens1 after flash than it should have
error flashInsufficientPaid1();
/// @notice Emitted if limitSqrtPrice parameter is incorrect
error invalidLimitSqrtPrice();
/// @notice Tick must be divisible by tickspacing
error tickIsNotSpaced();
/// @notice Emitted if a method is called that is accessible only to the factory owner or dedicated role
error notAllowed();
/// @notice Emitted if new tick spacing exceeds max allowed value
error invalidNewTickSpacing();
/// @notice Emitted if new community fee exceeds max allowed value
error invalidNewCommunityFee();
/// @notice Emitted if an attempt is made to manually change the fee value, but dynamic fee is enabled
error dynamicFeeActive();
/// @notice Emitted if an attempt is made by plugin to change the fee value, but dynamic fee is disabled
error dynamicFeeDisabled();
/// @notice Emitted if an attempt is made to change the plugin configuration, but the plugin is not connected
error pluginIsNotConnected();
/// @notice Emitted if a plugin returns invalid selector after hook call
/// @param expectedSelector The expected selector
error invalidHookResponse(bytes4 expectedSelector);
// #### LiquidityMath errors ####
/// @notice Emitted if liquidity underflows
error liquiditySub();
/// @notice Emitted if liquidity overflows
error liquidityAdd();
// #### TickManagement errors ####
/// @notice Emitted if the topTick parameter not greater then the bottomTick param
error topTickLowerOrEqBottomTick();
/// @notice Emitted if the bottomTick parameter is lower than min allowed value
error bottomTickLowerThanMIN();
/// @notice Emitted if the topTick parameter is greater than max allowed value
error topTickAboveMAX();
/// @notice Emitted if the liquidity value associated with the tick exceeds MAX_LIQUIDITY_PER_TICK
error liquidityOverflow();
/// @notice Emitted if an attempt is made to interact with an uninitialized tick
error tickIsNotInitialized();
/// @notice Emitted if there is an attempt to insert a new tick into the list of ticks with incorrect indexes of the previous and next ticks
error tickInvalidLinks();
// #### SafeTransfer errors ####
/// @notice Emitted if token transfer failed internally
error transferFailed();
// #### TickMath errors ####
/// @notice Emitted if tick is greater than the maximum or less than the minimum allowed value
error tickOutOfRange();
/// @notice Emitted if price is greater than the maximum or less than the minimum allowed value
error priceOutOfRange();
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.9;
import { FullMath } from "./FullMath.sol";
import { TickMath } from "./TickMath.sol";
import { IAlgebraV3Pool } from "../interfaces/IAlgebraV3Pool.sol";
import { IPancakeV3Pair } from "../interfaces/IPancakeV3Pair.sol";
/**
* @title OracleLibrary
*
*/
library OracleLibrary {
function consult(address _pool, uint32 _period) internal view returns (int24 timeWeightedAverageTick) {
require(_period != 0); // solhint-disable-line reason-string
uint32[] memory secondAgos = new uint32[](2);
secondAgos[0] = _period;
secondAgos[1] = 0;
(int56[] memory tickCumulatives, , ,) = IAlgebraV3Pool(_pool).getTimepoints(secondAgos);
int56 tickCumulativesDelta = tickCumulatives[1] - tickCumulatives[0];
timeWeightedAverageTick = int24(tickCumulativesDelta / int32(_period));
// Always round to negative infinity
if (tickCumulativesDelta < 0 && (tickCumulativesDelta % int32(_period) != 0)) timeWeightedAverageTick--;
}
function consultPancakeSwap(address _pool, uint32 _period) internal view returns (int24 timeWeightedAverageTick) {
require(_period != 0); // solhint-disable-line reason-string
uint32[] memory secondAgos = new uint32[](2);
secondAgos[0] = _period;
secondAgos[1] = 0;
(int56[] memory tickCumulatives, ) = IPancakeV3Pair(_pool).observe(secondAgos);
int56 tickCumulativesDelta = tickCumulatives[1] - tickCumulatives[0];
timeWeightedAverageTick = int24(tickCumulativesDelta / int32(_period));
// Always round to negative infinity
if (tickCumulativesDelta < 0 && (tickCumulativesDelta % int32(_period) != 0)) timeWeightedAverageTick--;
}
function getQuoteAtTick(
int24 tick,
uint128 baseAmount,
address baseToken,
address quoteToken
) internal pure returns (uint256 quoteAmount) {
uint160 sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
// Calculate quoteAmount with better precision if it doesn't overflow when multiplied by itself
if (sqrtRatioX96 <= type(uint128).max) {
uint256 ratioX192 = uint256(sqrtRatioX96) * sqrtRatioX96;
quoteAmount = baseToken < quoteToken
? FullMath.mulDiv(ratioX192, baseAmount, 1 << 192)
: FullMath.mulDiv(1 << 192, baseAmount, ratioX192);
} else {
uint256 ratioX128 = FullMath.mulDiv(sqrtRatioX96, sqrtRatioX96, 1 << 64);
quoteAmount = baseToken < quoteToken
? FullMath.mulDiv(ratioX128, baseAmount, 1 << 128)
: FullMath.mulDiv(1 << 128, baseAmount, ratioX128);
}
}
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.9;
import { IAlgebraPoolErrors } from "./IAlgebraPoolErrors.sol";
// solhint-disable
/**
* @title TickMath
*
* @notice Computes sqrt price for ticks of size 1.0001, i.e. sqrt(1.0001^tick) as fixed point Q64.96 numbers. Supports
* prices between 2**-128 and 2**128
*/
library TickMath {
/// @dev The minimum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**-128
int24 internal constant MIN_TICK = -887272;
/// @dev The maximum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**128
int24 internal constant MAX_TICK = -MIN_TICK;
/// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
/// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
/// @notice Calculates sqrt(1.0001^tick) * 2^96
/// @dev Throws if |tick| > max tick
/// @param tick The input tick for the above formula
/// @return price A Fixed point Q64.96 number representing the sqrt of the ratio of the two assets (token1/token0)
/// at the given tick
function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 price) {
unchecked {
// get abs value
int24 absTickMask = tick >> (24 - 1);
uint256 absTick = uint24((tick + absTickMask) ^ absTickMask);
if (absTick > uint24(MAX_TICK)) revert IAlgebraPoolErrors.tickOutOfRange();
uint256 ratio = 0x100000000000000000000000000000000;
if (absTick & 0x1 != 0) ratio = 0xfffcb933bd6fad37aa2d162d1a594001;
if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
if (absTick >= 0x40000) {
if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
}
if (tick > 0) {
assembly {
ratio := div(not(0), ratio)
}
}
// this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
// we then downcast because we know the result always fits within 160 bits due to our tick input constraint
// we round up in the division so getTickAtSqrtRatio of the output price is always consistent
price = uint160((ratio + 0xFFFFFFFF) >> 32);
}
}
/// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
/// @dev Throws in case price < MIN_SQRT_RATIO, as MIN_SQRT_RATIO is the lowest value getRatioAtTick may
/// ever return.
/// @param price The sqrt ratio for which to compute the tick as a Q64.96
/// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
function getTickAtSqrtRatio(uint160 price) internal pure returns (int24 tick) {
unchecked {
// second inequality must be >= because the price can never reach the price at the max tick
if (price < MIN_SQRT_RATIO || price >= MAX_SQRT_RATIO) revert IAlgebraPoolErrors.priceOutOfRange();
uint256 ratio = uint256(price) << 32;
uint256 r = ratio;
uint256 msb;
assembly {
let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(5, gt(r, 0xFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(4, gt(r, 0xFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(3, gt(r, 0xFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(2, gt(r, 0xF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(1, gt(r, 0x3))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := gt(r, 0x1)
msb := or(msb, f)
}
if (msb >= 128) r = ratio >> (msb - 127);
else r = ratio << (127 - msb);
int256 log_2 = (int256(msb) - 128) << 64;
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(63, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(62, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(61, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(60, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(59, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(58, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(57, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(56, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(55, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(54, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(53, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(52, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(51, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(50, f))
}
int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number
int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
// tick = tickLow == tickHi ? tickLow : getSqrtRatioAtTick(tickHi) <= price ? tickHi : tickLow;
if (tickLow == tickHi) {
tick = tickLow;
} else if (getSqrtRatioAtTick(tickHi) <= price) {
tick = tickHi;
} else {
tick = tickLow;
}
}
}
}{
"optimizer": {
"enabled": true,
"runs": 200,
"details": {
"yul": false
}
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"libraries": {}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"components":[{"components":[{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"tokenPair","type":"address"},{"internalType":"uint256","name":"weight","type":"uint256"}],"internalType":"struct IOracleAggregatorV2.OracleInfo[]","name":"oracleInfos","type":"tuple[]"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"address","name":"token","type":"address"}],"internalType":"struct IOracleAggregatorV2.TokenInfo[]","name":"_infos","type":"tuple[]"},{"internalType":"address","name":"_dolomiteMargin","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"components":[{"components":[{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"tokenPair","type":"address"},{"internalType":"uint256","name":"weight","type":"uint256"}],"internalType":"struct IOracleAggregatorV2.OracleInfo[]","name":"oracleInfos","type":"tuple[]"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"address","name":"token","type":"address"}],"indexed":false,"internalType":"struct IOracleAggregatorV2.TokenInfo","name":"info","type":"tuple"}],"name":"TokenInsertedOrUpdated","type":"event"},{"inputs":[],"name":"DOLOMITE_MARGIN","outputs":[{"internalType":"contract IDolomiteMargin","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"getDecimalsByToken","outputs":[{"internalType":"uint8","name":"_decimals","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"getOraclesByToken","outputs":[{"components":[{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"tokenPair","type":"address"},{"internalType":"uint256","name":"weight","type":"uint256"}],"internalType":"struct IOracleAggregatorV2.OracleInfo[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"getPrice","outputs":[{"components":[{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct IDolomiteStructs.MonetaryPrice","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"getTokenInfo","outputs":[{"components":[{"components":[{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"tokenPair","type":"address"},{"internalType":"uint256","name":"weight","type":"uint256"}],"internalType":"struct IOracleAggregatorV2.OracleInfo[]","name":"oracleInfos","type":"tuple[]"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"address","name":"token","type":"address"}],"internalType":"struct IOracleAggregatorV2.TokenInfo","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"address","name":"oracle","type":"address"},{"internalType":"address","name":"tokenPair","type":"address"},{"internalType":"uint256","name":"weight","type":"uint256"}],"internalType":"struct IOracleAggregatorV2.OracleInfo[]","name":"oracleInfos","type":"tuple[]"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"address","name":"token","type":"address"}],"internalType":"struct IOracleAggregatorV2.TokenInfo","name":"_info","type":"tuple"}],"name":"ownerInsertOrUpdateToken","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000e6ef4f0b2455bab92ce7cc78e35324ab58917de80000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _infos (tuple[]):
Arg [1] : _dolomiteMargin (address): 0xE6Ef4f0B2455bAB92ce7cC78E35324ab58917De8
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 000000000000000000000000e6ef4f0b2455bab92ce7cc78e35324ab58917de8
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
Loading...
Loading
0x2c640B79Ff62908fAE611e6a445c7E480324B77d
Net Worth in USD
$0.00
Net Worth in MNT
0
Multichain Portfolio | 35 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
Loading...
Loading
Loading...
Loading
Loading...
Loading
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.