From c66c8652063907f615941bffb28afd0910de4976 Mon Sep 17 00:00:00 2001 From: Filip Malachowicz Date: Fri, 1 Aug 2025 14:38:24 +0200 Subject: [PATCH 01/15] feat: SingleTokenConverter can whitelist assets to direct transfer them to destination. Moved poolsAssetsDirectTransfer mapping to AbstractTokenConverter. Used inherited poolsAssetsDirectTransfer mapping in RiskFundConverter. Modified SingleTokenConverter so whitelisted assets would be directly transfered to the destination address. --- .../TokenConverter/AbstractTokenConverter.sol | 84 +++++++-- .../TokenConverter/RiskFundConverter.sol | 81 +-------- .../TokenConverter/SingleTokenConverter.sol | 46 ++++- .../TokenConverter/AbstractTokenConverter.ts | 165 ++++++++++++++++++ tests/TokenConverter/RiskFundConverter.ts | 8 +- tests/TokenConverter/SingleTokenConverter.ts | 162 ++++++++++++++++- 6 files changed, 447 insertions(+), 99 deletions(-) diff --git a/contracts/TokenConverter/AbstractTokenConverter.sol b/contracts/TokenConverter/AbstractTokenConverter.sol index a28da476..a88662b2 100644 --- a/contracts/TokenConverter/AbstractTokenConverter.sol +++ b/contracts/TokenConverter/AbstractTokenConverter.sol @@ -120,10 +120,14 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @notice Address of the converterNetwork contract IConverterNetwork public converterNetwork; + /// @notice The mapping contains the assets for each receiver which are sent to destination directly + /// @dev Direct Transfer Receiver -> Asset -> bool(should transfer directly on true) + mapping(address => mapping(address => bool)) public poolsAssetsDirectTransfer; + /// @dev This empty reserved space is put in place to allow future versions to add new /// variables without shifting down storage in the inheritance chain. /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps - uint256[45] private __gap; + uint256[44] private __gap; /// @notice Emitted when config is updated for tokens pair event ConversionConfigUpdated( @@ -195,6 +199,9 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @notice Emitted when minimum amount to convert is updated event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert); + /// @notice Emitted after the poolsAssetsDirectTransfer mapping is updated + event PoolAssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value); + /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens error AmountOutMismatched(); @@ -326,6 +333,21 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo _setMinAmountToConvert(minAmountToConvert_); } + /// @notice Update the poolsAssetsDirectTransfer mapping + /// @param receivers Addresses of the pools + /// @param assets Addresses of the assets need to be added for direct transfer + /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. + /// @custom:event PoolAssetsDirectTransferUpdated emits on success + /// @custom:access Restricted by ACM + function setPoolsAssetsDirectTransfer( + address[] calldata receivers, + address[][] calldata assets, + bool[][] calldata values + ) external virtual { + _checkAccessAllowed("setPoolsAssetsDirectTransfer(address[],address[][],bool[][])"); + _setPoolsAssetsDirectTransfer(receivers, assets, values); + } + /// @notice Batch sets the conversion configurations /// @param tokenAddressIn Address of tokenIn /// @param tokenAddressesOut Array of addresses of tokenOut @@ -527,11 +549,7 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @custom:event Emits SweepToken event on success /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero /// @custom:access Only Governance - function sweepToken( - address tokenAddress, - address to, - uint256 amount - ) external onlyOwner nonReentrant { + function sweepToken(address tokenAddress, address to, uint256 amount) external onlyOwner nonReentrant { ensureNonzeroAddress(tokenAddress); ensureNonzeroAddress(to); ensureNonzeroValue(amount); @@ -842,11 +860,7 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @param to Address of the tokenAddressOut receiver /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa - function _doTransferOut( - address tokenAddressOut, - address to, - uint256 amountConvertedMantissa - ) internal { + function _doTransferOut(address tokenAddressOut, address to, uint256 amountConvertedMantissa) internal { uint256 maxTokenOutReserve = balanceOf(tokenAddressOut); /// If contract has less liquidity for tokenAddressOut than amountOutMantissa @@ -964,17 +978,13 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @param comptroller Comptroller address (pool) /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset /// @param amountToConvert Amount of the tokenAddressOut transferred to converter - function _privateConversion( - address comptroller, - address tokenAddressOut, - uint256 amountToConvert - ) internal { + function _privateConversion(address comptroller, address tokenAddressOut, uint256 amountToConvert) internal { address tokenAddressIn = _getDestinationBaseAsset(); address _destinationAddress = destinationAddress; uint256 convertedTokenInBalance; if (address(converterNetwork) != address(0)) { (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork - .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn); + .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn); uint256 convertersLength = converterAddresses.length; for (uint256 i; i < convertersLength; ) { if (converterBalances[i] == 0) break; @@ -1054,6 +1064,46 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo } } + /// @dev Update the poolsAssetsDirectTransfer mapping + /// @param receivers Addresses of the pools + /// @param assets Addresses of the assets need to be added for direct transfer + /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. + /// @custom:event PoolAssetsDirectTransferUpdated emits on success + /// @custom:error InputLengthMisMatch thrown when comptrollers array length is not equal to assets array length + function _setPoolsAssetsDirectTransfer( + address[] calldata receivers, + address[][] calldata assets, + bool[][] calldata values + ) internal virtual { + uint256 receiversLength = receivers.length; + + if ((receiversLength != assets.length) || (receiversLength != values.length)) { + revert InputLengthMisMatch(); + } + + for (uint256 i; i < receiversLength; ) { + address[] memory poolAssets = assets[i]; + bool[] memory assetsValues = values[i]; + uint256 poolAssetsLength = poolAssets.length; + + if (poolAssetsLength != assetsValues.length) { + revert InputLengthMisMatch(); + } + + for (uint256 j; j < poolAssetsLength; ) { + poolsAssetsDirectTransfer[receivers[i]][poolAssets[j]] = assetsValues[j]; + emit PoolAssetsDirectTransferUpdated(receivers[i], poolAssets[j], assetsValues[j]); + unchecked { + ++j; + } + } + + unchecked { + ++i; + } + } + } + /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn /// @dev This function retrieves values without altering token prices. /// @param amountInMantissa Amount of tokenAddressIn diff --git a/contracts/TokenConverter/RiskFundConverter.sol b/contracts/TokenConverter/RiskFundConverter.sol index 9ce0815a..dd7bfe13 100644 --- a/contracts/TokenConverter/RiskFundConverter.sol +++ b/contracts/TokenConverter/RiskFundConverter.sol @@ -42,10 +42,6 @@ contract RiskFundConverter is AbstractTokenConverter { /// @notice Address of pool registry contract address public poolRegistry; - /// @notice The mapping contains the assets for each pool which are sent to RiskFund directly - /// @dev Comptroller(pool) -> Asset -> bool(should transfer directly on true) - mapping(address => mapping(address => bool)) public poolsAssetsDirectTransfer; - /// @notice Emitted when pool registry address is updated event PoolRegistryUpdated(address indexed oldPoolRegistry, address indexed newPoolRegistry); @@ -61,12 +57,6 @@ contract RiskFundConverter is AbstractTokenConverter { uint256 amount ); - /// @notice Emitted after the poolsAssetsDirectTransfer mapping is updated - event PoolAssetsDirectTransferUpdated(address indexed comptroller, address indexed asset, bool value); - - // Error thrown when comptrollers array length is not equal to assets array length - error InvalidArguments(); - /// @notice thrown when amount entered is greater than balance error InsufficientBalance(); @@ -82,11 +72,7 @@ contract RiskFundConverter is AbstractTokenConverter { /// @param vBNB_ Address of the vBNB /// @param nativeWrapped_ Address of the wrapped native currency /// @custom:oz-upgrades-unsafe-allow constructor - constructor( - address corePoolComptroller_, - address vBNB_, - address nativeWrapped_ - ) { + constructor(address corePoolComptroller_, address vBNB_, address nativeWrapped_) { ensureNonzeroAddress(corePoolComptroller_); ensureNonzeroAddress(vBNB_); ensureNonzeroAddress(nativeWrapped_); @@ -137,21 +123,6 @@ contract RiskFundConverter is AbstractTokenConverter { poolRegistry = poolRegistry_; } - /// @notice Update the poolsAssetsDirectTransfer mapping - /// @param comptrollers Addresses of the pools - /// @param assets Addresses of the assets need to be added for direct transfer - /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. - /// @custom:event PoolAssetsDirectTransferUpdated emits on success - /// @custom:access Restricted by ACM - function setPoolsAssetsDirectTransfer( - address[] calldata comptrollers, - address[][] calldata assets, - bool[][] calldata values - ) external { - _checkAccessAllowed("setPoolsAssetsDirectTransfer(address[],address[][],bool[][])"); - _setPoolsAssetsDirectTransfer(comptrollers, assets, values); - } - /// @dev Get the Amount of the asset in the risk fund for the specific pool /// @param comptroller Comptroller address (pool) /// @param asset Asset address @@ -301,46 +272,6 @@ contract RiskFundConverter is AbstractTokenConverter { emit AssetsReservesUpdated(pool, tokenAddress, poolAmountShare); } - /// @dev Update the poolsAssetsDirectTransfer mapping - /// @param comptrollers Addresses of the pools - /// @param assets Addresses of the assets need to be added for direct transfer - /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. - /// @custom:event PoolAssetsDirectTransferUpdated emits on success - /// @custom:error InvalidArguments thrown when comptrollers array length is not equal to assets array length - function _setPoolsAssetsDirectTransfer( - address[] calldata comptrollers, - address[][] calldata assets, - bool[][] calldata values - ) internal { - uint256 comptrollersLength = comptrollers.length; - - if ((comptrollersLength != assets.length) || (comptrollersLength != values.length)) { - revert InvalidArguments(); - } - - for (uint256 i; i < comptrollersLength; ) { - address[] memory poolAssets = assets[i]; - bool[] memory assetsValues = values[i]; - uint256 poolAssetsLength = poolAssets.length; - - if (poolAssetsLength != assetsValues.length) { - revert InvalidArguments(); - } - - for (uint256 j; j < poolAssetsLength; ) { - poolsAssetsDirectTransfer[comptrollers[i]][poolAssets[j]] = assetsValues[j]; - emit PoolAssetsDirectTransferUpdated(comptrollers[i], poolAssets[j], assetsValues[j]); - unchecked { - ++j; - } - } - - unchecked { - ++i; - } - } - } - /// @dev Update the reserve of the asset for the specific pool after transferring to risk fund /// and transferring funds to the protocol share reserve /// @param comptroller Comptroller address (pool) @@ -348,11 +279,10 @@ contract RiskFundConverter is AbstractTokenConverter { /// @return balanceDifference Amount of asset, for _privateConversion /// @custom:event AssetTransferredToDestination emits when poolsAssetsDirectTransfer is enabled for entered comptroller and asset /// @custom:error MarketNotExistInPool When asset does not exist in the pool(comptroller) - function _updateAssetsState(address comptroller, address asset) - internal - override - returns (uint256 balanceDifference) - { + function _updateAssetsState( + address comptroller, + address asset + ) internal override returns (uint256 balanceDifference) { if (!ensureAssetListed(comptroller, asset)) revert MarketNotExistInPool(comptroller, asset); IERC20Upgradeable token = IERC20Upgradeable(asset); @@ -362,6 +292,7 @@ contract RiskFundConverter is AbstractTokenConverter { unchecked { balanceDifference = currentBalance - assetReserve; } + if (poolsAssetsDirectTransfer[comptroller][asset]) { uint256 previousDestinationBalance = token.balanceOf(destinationAddress); token.safeTransfer(destinationAddress, balanceDifference); diff --git a/contracts/TokenConverter/SingleTokenConverter.sol b/contracts/TokenConverter/SingleTokenConverter.sol index 86a7320f..175c39a0 100644 --- a/contracts/TokenConverter/SingleTokenConverter.sol +++ b/contracts/TokenConverter/SingleTokenConverter.sol @@ -29,6 +29,9 @@ contract SingleTokenConverter is AbstractTokenConverter { uint256 amount ); + /// @dev Error thrown when only the destination address is allowed for direct transfer + error OnlyDestinationAddressAllowedForDirectTransfer(); + /// @custom:oz-upgrades-unsafe-allow constructor constructor() { // Note that the contract is upgradeable. Use initialize() or reinitializers @@ -78,7 +81,7 @@ contract SingleTokenConverter is AbstractTokenConverter { uint256 balance = token.balanceOf(address(this)); balanceLeft = balance; - if (asset == baseAsset) { + if (asset == baseAsset || poolsAssetsDirectTransfer[destinationAddress][asset]) { balanceLeft = 0; token.safeTransfer(destinationAddress, balance); emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance); @@ -109,6 +112,47 @@ contract SingleTokenConverter is AbstractTokenConverter { } } + /// @dev Override to only allow setting poolsAssetsDirectTransfer for destinationAddress + /// @param assets Addresses of the assets need to be added for direct transfer + /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. + /// @custom:event PoolAssetsDirectTransferUpdated emits on success + /// @custom:error OnlyDestinationAddressAllowedForDirectTransfer is thrown when receivers array is not an array of one element equal to the destination address + /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match + function _setPoolsAssetsDirectTransfer( + address[] calldata receivers, + address[][] calldata assets, + bool[][] calldata values + ) internal override { + uint256 receiversLength = receivers.length; + uint256 destinationAddressIndex = 0; + + // Ensure that the destinationAddress is the only receiver + if (receiversLength != 1 || receivers[destinationAddressIndex] != destinationAddress) { + revert OnlyDestinationAddressAllowedForDirectTransfer(); + } + + if ((receiversLength != assets.length) || (receiversLength != values.length)) { + revert InputLengthMisMatch(); + } + + address[] memory poolAssets = assets[destinationAddressIndex]; + bool[] memory assetsValues = values[destinationAddressIndex]; + uint256 poolAssetsLength = poolAssets.length; + + if (poolAssetsLength != assetsValues.length) { + revert InputLengthMisMatch(); + } + + for (uint256 j; j < poolAssetsLength; ) { + // Always use destinationAddress as the direct transfer receiver address + poolsAssetsDirectTransfer[destinationAddress][poolAssets[j]] = assetsValues[j]; + emit PoolAssetsDirectTransferUpdated(destinationAddress, poolAssets[j], assetsValues[j]); + unchecked { + ++j; + } + } + } + /// @dev Sets the base asset for the contract /// @param baseAsset_ The new address of the base asset /// @custom:error ZeroAddressNotAllowed is thrown when address is zero diff --git a/tests/TokenConverter/AbstractTokenConverter.ts b/tests/TokenConverter/AbstractTokenConverter.ts index 8294a016..38ba9ada 100644 --- a/tests/TokenConverter/AbstractTokenConverter.ts +++ b/tests/TokenConverter/AbstractTokenConverter.ts @@ -975,6 +975,171 @@ describe("MockConverter: tests", () => { }); }); + describe("Pools direct transfer", () => { + it("Revert on invalid access control", async () => { + await accessControl.isAllowedToCall.returns(false); + + await expect( + converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[true]]), + ).to.be.revertedWithCustomError(converter, "Unauthorized"); + }); + + it("Success on the setPoolsAssetsDirectTransfer", async () => { + await accessControl.isAllowedToCall.returns(true); + + await expect(converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[true]])) + .to.emit(converter, "PoolAssetsDirectTransferUpdated") + .withArgs(comptroller.address, tokenIn.address, true); + + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(true); + }); + + it("Success on setting multiple pools and assets", async () => { + await accessControl.isAllowedToCall.returns(true); + + const [, , poolB] = await ethers.getSigners(); + + await expect( + converter.setPoolsAssetsDirectTransfer( + [comptroller.address, poolB.address], + [[tokenIn.address, tokenOut.address], [tokenIn.address]], + [[true, false], [true]], + ), + ) + .to.emit(converter, "PoolAssetsDirectTransferUpdated") + .withArgs(comptroller.address, tokenIn.address, true) + .to.emit(converter, "PoolAssetsDirectTransferUpdated") + .withArgs(comptroller.address, tokenOut.address, false) + .to.emit(converter, "PoolAssetsDirectTransferUpdated") + .withArgs(poolB.address, tokenIn.address, true); + + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(true); + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenOut.address)).to.equal(false); + expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenIn.address)).to.equal(true); + }); + + it("Revert on invalid parameters - comptrollers and assets length mismatch", async () => { + await accessControl.isAllowedToCall.returns(true); + + const [, , poolB] = await ethers.getSigners(); + + await expect( + converter.setPoolsAssetsDirectTransfer( + [comptroller.address, poolB.address], + [[tokenIn.address]], + [[true], [true]], + ), + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + }); + + it("Revert on invalid parameters - comptrollers and values length mismatch", async () => { + await accessControl.isAllowedToCall.returns(true); + + await expect( + converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[true], [false]]), + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + }); + + it("Revert on invalid parameters - assets and values nested array length mismatch", async () => { + await accessControl.isAllowedToCall.returns(true); + + await expect( + converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address, tokenOut.address]], [[true]]), + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + }); + + it("Update existing poolsAssetsDirectTransfer mapping", async () => { + await accessControl.isAllowedToCall.returns(true); + + await converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[true]]); + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(true); + + await expect(converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[false]])) + .to.emit(converter, "PoolAssetsDirectTransferUpdated") + .withArgs(comptroller.address, tokenIn.address, false); + + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(false); + }); + + it("Handle empty arrays correctly", async () => { + await accessControl.isAllowedToCall.returns(true); + + await converter.setPoolsAssetsDirectTransfer([], [], []); + + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(false); + }); + + it("Verify poolsAssetsDirectTransfer mapping getter returns correct values", async () => { + await accessControl.isAllowedToCall.returns(true); + + const [, , poolB, poolC] = await ethers.getSigners(); + + await converter.setPoolsAssetsDirectTransfer( + [comptroller.address, poolB.address, poolC.address], + [[tokenIn.address, tokenOut.address], [tokenIn.address], [tokenOut.address]], + [[true, false], [false], [true]], + ); + + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(true); + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenOut.address)).to.equal(false); + expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenIn.address)).to.equal(false); + expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenOut.address)).to.equal(false); + expect(await converter.poolsAssetsDirectTransfer(poolC.address, tokenIn.address)).to.equal(false); + expect(await converter.poolsAssetsDirectTransfer(poolC.address, tokenOut.address)).to.equal(true); + }); + + it("Verify multiple batch operations work correctly", async () => { + await accessControl.isAllowedToCall.returns(true); + + const [, , poolB, poolC, poolD] = await ethers.getSigners(); + + // First batch + await converter.setPoolsAssetsDirectTransfer( + [comptroller.address, poolB.address], + [[tokenIn.address], [tokenOut.address, tokenOut2.address]], + [[true], [true, false]], + ); + + // Second batch - should update existing and add new + await converter.setPoolsAssetsDirectTransfer( + [comptroller.address, poolC.address, poolD.address], + [[tokenIn.address, tokenOut.address], [tokenIn.address], [tokenOut2.address]], + [[false, true], [true], [true]], + ); + + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(false); + expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenOut.address)).to.equal(true); + expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenOut.address)).to.equal(true); + expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenOut2.address)).to.equal(false); + expect(await converter.poolsAssetsDirectTransfer(poolC.address, tokenIn.address)).to.equal(true); + expect(await converter.poolsAssetsDirectTransfer(poolD.address, tokenOut2.address)).to.equal(true); + }); + + it("Verify events are emitted for all changes in batch operations", async () => { + await accessControl.isAllowedToCall.returns(true); + + const [, , poolB] = await ethers.getSigners(); + + const tx = await converter.setPoolsAssetsDirectTransfer( + [comptroller.address, poolB.address], + [[tokenIn.address, tokenOut.address], [tokenOut2.address]], + [[true, false], [true]], + ); + + await expect(tx) + .to.emit(converter, "PoolAssetsDirectTransferUpdated") + .withArgs(comptroller.address, tokenIn.address, true); + + await expect(tx) + .to.emit(converter, "PoolAssetsDirectTransferUpdated") + .withArgs(comptroller.address, tokenOut.address, false); + + await expect(tx) + .to.emit(converter, "PoolAssetsDirectTransferUpdated") + .withArgs(poolB.address, tokenOut2.address, true); + }); + }); + describe("Private conversion: tests", () => { beforeEach(async () => { await destination.convertibleBaseAsset.returns(tokenIn.address); diff --git a/tests/TokenConverter/RiskFundConverter.ts b/tests/TokenConverter/RiskFundConverter.ts index 156ce16b..3b2f765b 100644 --- a/tests/TokenConverter/RiskFundConverter.ts +++ b/tests/TokenConverter/RiskFundConverter.ts @@ -265,19 +265,19 @@ describe("Risk fund Converter: tests", () => { [[tokenIn.address], [tokenIn.address]], [[true]], ), - ).to.be.revertedWithCustomError(converter, "InvalidArguments"); + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); await expect( converter.setPoolsAssetsDirectTransfer([poolA.address], [[tokenIn.address], [tokenIn.address]], [[true]]), - ).to.be.revertedWithCustomError(converter, "InvalidArguments"); + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); await expect( converter.setPoolsAssetsDirectTransfer([poolA.address], [[tokenIn.address, tokenIn.address]], [[true]]), - ).to.be.revertedWithCustomError(converter, "InvalidArguments"); + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); await expect( converter.setPoolsAssetsDirectTransfer([poolA.address], [[tokenIn.address]], [[true, true]]), - ).to.be.revertedWithCustomError(converter, "InvalidArguments"); + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); }); }); diff --git a/tests/TokenConverter/SingleTokenConverter.ts b/tests/TokenConverter/SingleTokenConverter.ts index f9629013..22c28f8d 100644 --- a/tests/TokenConverter/SingleTokenConverter.ts +++ b/tests/TokenConverter/SingleTokenConverter.ts @@ -2,7 +2,7 @@ import { FakeContract, MockContract, smock } from "@defi-wonderland/smock"; import { loadFixture } from "@nomicfoundation/hardhat-network-helpers"; import chai from "chai"; import { parseUnits } from "ethers/lib/utils"; -import { ethers } from "hardhat"; +import { ethers, upgrades } from "hardhat"; import { IAccessControlManagerV8, @@ -24,6 +24,7 @@ chai.use(smock.matchers); let accessControl: FakeContract; let converter: MockContract; let tokenIn: MockContract; +let whitelistedTokenIn: MockContract; let tokenOut: MockContract; let xvs: MockContract; let oracle: FakeContract; @@ -52,6 +53,9 @@ async function fixture(): Promise { tokenOut = await MockToken.deploy("TokenOut", "tokenOut", 18); await tokenOut.faucet(parseUnits("1000", 18)); + whitelistedTokenIn = await MockToken.deploy("WhitelistedTokenIn", "whitelistedTokenIn", 18); + await whitelistedTokenIn.faucet(parseUnits("1000", 18)); + xvs = await MockToken.deploy("XVS", "xvs", 18); await xvs.faucet(parseUnits("1000", 18)); @@ -67,7 +71,7 @@ async function fixture(): Promise { } describe("XVS vault Converter: tests", () => { - before(async function () { + beforeEach(async function () { await loadFixture(fixture); }); @@ -121,4 +125,158 @@ describe("XVS vault Converter: tests", () => { .withArgs(xvs.address, unknownAddress.address); }); }); + + describe("Whitelisted tokens direct transfer", () => { + it("Revert on invalid access control", async () => { + await accessControl.isAllowedToCall.returns(false); + + await expect( + converter.setPoolsAssetsDirectTransfer([xvsVaultTreasury.address], [[whitelistedTokenIn.address]], [[true]]), + ).to.be.revertedWithCustomError(converter, "Unauthorized"); + }); + + it("Success on the setPoolsAssetsDirectTransfer", async () => { + await accessControl.isAllowedToCall.returns(true); + + await expect( + converter.setPoolsAssetsDirectTransfer([xvsVaultTreasury.address], [[whitelistedTokenIn.address]], [[true]]), + ) + .to.emit(converter, "PoolAssetsDirectTransferUpdated") + .withArgs(xvsVaultTreasury.address, whitelistedTokenIn.address, true); + + expect(await converter.poolsAssetsDirectTransfer(xvsVaultTreasury.address, whitelistedTokenIn.address)).to.equal( + true, + ); + }); + + it("Transfer funds to treasury directly when using whitelisted token", async () => { + const [, fakeComptroller] = await ethers.getSigners(); + const whitelistedTokenAmount = convertToUnit(10, 18); + + expect(await whitelistedTokenIn.balanceOf(xvsVaultTreasury.address)).to.equal(0); + expect(await whitelistedTokenIn.balanceOf(converter.address)).to.equal(0); + await whitelistedTokenIn.transfer(converter.address, whitelistedTokenAmount); + await converter.setPoolsAssetsDirectTransfer( + [xvsVaultTreasury.address], + [[whitelistedTokenIn.address]], + [[true]], + ); + await converter.updateAssetsState(fakeComptroller.address, whitelistedTokenIn.address); + + expect(await whitelistedTokenIn.balanceOf(converter.address)).to.equal(0); + expect(await whitelistedTokenIn.balanceOf(xvsVaultTreasury.address)).to.equal(whitelistedTokenAmount); + }); + + it("Revert on when trying to set to a differnet address than xvsVaultTreasury", async () => { + await accessControl.isAllowedToCall.returns(true); + await expect( + converter.setPoolsAssetsDirectTransfer([whitelistedTokenIn.address], [[whitelistedTokenIn.address]], [[true]]), + ).to.be.revertedWithCustomError(converter, "OnlyDestinationAddressAllowedForDirectTransfer"); + + await expect( + converter.setPoolsAssetsDirectTransfer( + [xvsVaultTreasury.address, xvsVaultTreasury.address], + [[whitelistedTokenIn.address], [whitelistedTokenIn.address]], + [[true]], + ), + ).to.be.revertedWithCustomError(converter, "OnlyDestinationAddressAllowedForDirectTransfer"); + }); + + it("Revert on invalid parameters lengths", async () => { + await accessControl.isAllowedToCall.returns(true); + + await expect( + converter.setPoolsAssetsDirectTransfer( + [xvsVaultTreasury.address], + [[whitelistedTokenIn.address], [whitelistedTokenIn.address]], + [[true]], + ), + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + + await expect( + converter.setPoolsAssetsDirectTransfer( + [xvsVaultTreasury.address], + [[whitelistedTokenIn.address, whitelistedTokenIn.address]], + [[true]], + ), + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + + await expect( + converter.setPoolsAssetsDirectTransfer( + [xvsVaultTreasury.address], + [[whitelistedTokenIn.address]], + [[true, true]], + ), + ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + }); + }); + + describe("setBaseAsset", () => { + it("Should revert on non-owner call", async () => { + const [, user] = await ethers.getSigners(); + await expect(converter.connect(user).setBaseAsset(tokenIn.address)).to.be.revertedWith( + "Ownable: caller is not the owner", + ); + }); + + it("Should revert on zero address", async () => { + await expect(converter.setBaseAsset(ethers.constants.AddressZero)).to.be.revertedWithCustomError( + converter, + "ZeroAddressNotAllowed", + ); + }); + + it("Should succeed on updating existing base asset", async () => { + await converter.setBaseAsset(tokenIn.address); + expect(await converter.baseAsset()).to.equal(tokenIn.address); + + const tx = await converter.setBaseAsset(tokenOut.address); + expect(tx).to.emit(converter, "BaseAssetUpdated").withArgs(tokenIn.address, tokenOut.address); + + expect(await converter.baseAsset()).to.equal(tokenOut.address); + }); + + it("Should succeed on setting same base asset multiple times", async () => { + await converter.setBaseAsset(tokenIn.address); + expect(await converter.baseAsset()).to.equal(tokenIn.address); + + const tx = await converter.setBaseAsset(tokenIn.address); + expect(tx).to.emit(converter, "BaseAssetUpdated").withArgs(tokenIn.address, tokenIn.address); + + expect(await converter.baseAsset()).to.equal(tokenIn.address); + }); + }); + + describe("balanceOf", () => { + it("Should return zero for token not in contract", async () => { + expect(await converter.balanceOf(tokenIn.address)).to.equal(0); + expect(await converter.balanceOf(tokenOut.address)).to.equal(0); + }); + + it("Should return correct balance for single token", async () => { + const amount = convertToUnit(100, 18); + await tokenIn.transfer(converter.address, amount); + + expect(await converter.balanceOf(tokenIn.address)).to.equal(amount); + expect(await converter.balanceOf(tokenOut.address)).to.equal(0); + }); + + it("Should return correct balances for multiple tokens", async () => { + const tokenInAmount = convertToUnit(50, 18); + const tokenOutAmount = convertToUnit(75, 18); + const xvsAmount = convertToUnit(25, 18); + + await tokenIn.transfer(converter.address, tokenInAmount); + await tokenOut.transfer(converter.address, tokenOutAmount); + await xvs.transfer(converter.address, xvsAmount); + + expect(await converter.balanceOf(tokenIn.address)).to.equal(tokenInAmount); + expect(await converter.balanceOf(tokenOut.address)).to.equal(tokenOutAmount); + expect(await converter.balanceOf(xvs.address)).to.equal(xvsAmount); + }); + + it("Should handle zero address token with no revert", async () => { + await expect(converter.balanceOf(ethers.constants.AddressZero)).to.be.reverted; + }); + }); }); From 1b1b377901da3e845f5e0e80f77cc736a52c1e3f Mon Sep 17 00:00:00 2001 From: Filip Malachowicz Date: Mon, 4 Aug 2025 09:49:45 +0200 Subject: [PATCH 02/15] feat: move poolsAssetsDirectTransfer from AbstractTokenConverter --- .../TokenConverter/AbstractTokenConverter.sol | 84 ++------- .../TokenConverter/RiskFundConverter.sol | 80 ++++++++- .../TokenConverter/SingleTokenConverter.sol | 24 ++- .../TokenConverter/AbstractTokenConverter.ts | 165 ------------------ tests/TokenConverter/RiskFundConverter.ts | 8 +- 5 files changed, 119 insertions(+), 242 deletions(-) diff --git a/contracts/TokenConverter/AbstractTokenConverter.sol b/contracts/TokenConverter/AbstractTokenConverter.sol index a88662b2..a28da476 100644 --- a/contracts/TokenConverter/AbstractTokenConverter.sol +++ b/contracts/TokenConverter/AbstractTokenConverter.sol @@ -120,14 +120,10 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @notice Address of the converterNetwork contract IConverterNetwork public converterNetwork; - /// @notice The mapping contains the assets for each receiver which are sent to destination directly - /// @dev Direct Transfer Receiver -> Asset -> bool(should transfer directly on true) - mapping(address => mapping(address => bool)) public poolsAssetsDirectTransfer; - /// @dev This empty reserved space is put in place to allow future versions to add new /// variables without shifting down storage in the inheritance chain. /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps - uint256[44] private __gap; + uint256[45] private __gap; /// @notice Emitted when config is updated for tokens pair event ConversionConfigUpdated( @@ -199,9 +195,6 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @notice Emitted when minimum amount to convert is updated event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert); - /// @notice Emitted after the poolsAssetsDirectTransfer mapping is updated - event PoolAssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value); - /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens error AmountOutMismatched(); @@ -333,21 +326,6 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo _setMinAmountToConvert(minAmountToConvert_); } - /// @notice Update the poolsAssetsDirectTransfer mapping - /// @param receivers Addresses of the pools - /// @param assets Addresses of the assets need to be added for direct transfer - /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. - /// @custom:event PoolAssetsDirectTransferUpdated emits on success - /// @custom:access Restricted by ACM - function setPoolsAssetsDirectTransfer( - address[] calldata receivers, - address[][] calldata assets, - bool[][] calldata values - ) external virtual { - _checkAccessAllowed("setPoolsAssetsDirectTransfer(address[],address[][],bool[][])"); - _setPoolsAssetsDirectTransfer(receivers, assets, values); - } - /// @notice Batch sets the conversion configurations /// @param tokenAddressIn Address of tokenIn /// @param tokenAddressesOut Array of addresses of tokenOut @@ -549,7 +527,11 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @custom:event Emits SweepToken event on success /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero /// @custom:access Only Governance - function sweepToken(address tokenAddress, address to, uint256 amount) external onlyOwner nonReentrant { + function sweepToken( + address tokenAddress, + address to, + uint256 amount + ) external onlyOwner nonReentrant { ensureNonzeroAddress(tokenAddress); ensureNonzeroAddress(to); ensureNonzeroValue(amount); @@ -860,7 +842,11 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @param to Address of the tokenAddressOut receiver /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa - function _doTransferOut(address tokenAddressOut, address to, uint256 amountConvertedMantissa) internal { + function _doTransferOut( + address tokenAddressOut, + address to, + uint256 amountConvertedMantissa + ) internal { uint256 maxTokenOutReserve = balanceOf(tokenAddressOut); /// If contract has less liquidity for tokenAddressOut than amountOutMantissa @@ -978,13 +964,17 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo /// @param comptroller Comptroller address (pool) /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset /// @param amountToConvert Amount of the tokenAddressOut transferred to converter - function _privateConversion(address comptroller, address tokenAddressOut, uint256 amountToConvert) internal { + function _privateConversion( + address comptroller, + address tokenAddressOut, + uint256 amountToConvert + ) internal { address tokenAddressIn = _getDestinationBaseAsset(); address _destinationAddress = destinationAddress; uint256 convertedTokenInBalance; if (address(converterNetwork) != address(0)) { (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork - .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn); + .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn); uint256 convertersLength = converterAddresses.length; for (uint256 i; i < convertersLength; ) { if (converterBalances[i] == 0) break; @@ -1064,46 +1054,6 @@ abstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenCo } } - /// @dev Update the poolsAssetsDirectTransfer mapping - /// @param receivers Addresses of the pools - /// @param assets Addresses of the assets need to be added for direct transfer - /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. - /// @custom:event PoolAssetsDirectTransferUpdated emits on success - /// @custom:error InputLengthMisMatch thrown when comptrollers array length is not equal to assets array length - function _setPoolsAssetsDirectTransfer( - address[] calldata receivers, - address[][] calldata assets, - bool[][] calldata values - ) internal virtual { - uint256 receiversLength = receivers.length; - - if ((receiversLength != assets.length) || (receiversLength != values.length)) { - revert InputLengthMisMatch(); - } - - for (uint256 i; i < receiversLength; ) { - address[] memory poolAssets = assets[i]; - bool[] memory assetsValues = values[i]; - uint256 poolAssetsLength = poolAssets.length; - - if (poolAssetsLength != assetsValues.length) { - revert InputLengthMisMatch(); - } - - for (uint256 j; j < poolAssetsLength; ) { - poolsAssetsDirectTransfer[receivers[i]][poolAssets[j]] = assetsValues[j]; - emit PoolAssetsDirectTransferUpdated(receivers[i], poolAssets[j], assetsValues[j]); - unchecked { - ++j; - } - } - - unchecked { - ++i; - } - } - } - /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn /// @dev This function retrieves values without altering token prices. /// @param amountInMantissa Amount of tokenAddressIn diff --git a/contracts/TokenConverter/RiskFundConverter.sol b/contracts/TokenConverter/RiskFundConverter.sol index dd7bfe13..299c7736 100644 --- a/contracts/TokenConverter/RiskFundConverter.sol +++ b/contracts/TokenConverter/RiskFundConverter.sol @@ -42,6 +42,10 @@ contract RiskFundConverter is AbstractTokenConverter { /// @notice Address of pool registry contract address public poolRegistry; + /// @notice The mapping contains the assets for each pool which are sent to RiskFund directly + /// @dev Comptroller(pool) -> Asset -> bool(should transfer directly on true) + mapping(address => mapping(address => bool)) public poolsAssetsDirectTransfer; + /// @notice Emitted when pool registry address is updated event PoolRegistryUpdated(address indexed oldPoolRegistry, address indexed newPoolRegistry); @@ -57,6 +61,12 @@ contract RiskFundConverter is AbstractTokenConverter { uint256 amount ); + /// @notice Emitted after the poolsAssetsDirectTransfer mapping is updated + event PoolAssetsDirectTransferUpdated(address indexed comptroller, address indexed asset, bool value); + + // Error thrown when comptrollers array length is not equal to assets array length + error InvalidArguments(); + /// @notice thrown when amount entered is greater than balance error InsufficientBalance(); @@ -72,7 +82,11 @@ contract RiskFundConverter is AbstractTokenConverter { /// @param vBNB_ Address of the vBNB /// @param nativeWrapped_ Address of the wrapped native currency /// @custom:oz-upgrades-unsafe-allow constructor - constructor(address corePoolComptroller_, address vBNB_, address nativeWrapped_) { + constructor( + address corePoolComptroller_, + address vBNB_, + address nativeWrapped_ + ) { ensureNonzeroAddress(corePoolComptroller_); ensureNonzeroAddress(vBNB_); ensureNonzeroAddress(nativeWrapped_); @@ -123,6 +137,21 @@ contract RiskFundConverter is AbstractTokenConverter { poolRegistry = poolRegistry_; } + /// @notice Update the poolsAssetsDirectTransfer mapping + /// @param comptrollers Addresses of the pools + /// @param assets Addresses of the assets need to be added for direct transfer + /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. + /// @custom:event PoolAssetsDirectTransferUpdated emits on success + /// @custom:access Restricted by ACM + function setPoolsAssetsDirectTransfer( + address[] calldata comptrollers, + address[][] calldata assets, + bool[][] calldata values + ) external { + _checkAccessAllowed("setPoolsAssetsDirectTransfer(address[],address[][],bool[][])"); + _setPoolsAssetsDirectTransfer(comptrollers, assets, values); + } + /// @dev Get the Amount of the asset in the risk fund for the specific pool /// @param comptroller Comptroller address (pool) /// @param asset Asset address @@ -272,6 +301,46 @@ contract RiskFundConverter is AbstractTokenConverter { emit AssetsReservesUpdated(pool, tokenAddress, poolAmountShare); } + /// @dev Update the poolsAssetsDirectTransfer mapping + /// @param comptrollers Addresses of the pools + /// @param assets Addresses of the assets need to be added for direct transfer + /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. + /// @custom:event PoolAssetsDirectTransferUpdated emits on success + /// @custom:error InvalidArguments thrown when comptrollers array length is not equal to assets array length + function _setPoolsAssetsDirectTransfer( + address[] calldata comptrollers, + address[][] calldata assets, + bool[][] calldata values + ) internal { + uint256 comptrollersLength = comptrollers.length; + + if ((comptrollersLength != assets.length) || (comptrollersLength != values.length)) { + revert InvalidArguments(); + } + + for (uint256 i; i < comptrollersLength; ) { + address[] memory poolAssets = assets[i]; + bool[] memory assetsValues = values[i]; + uint256 poolAssetsLength = poolAssets.length; + + if (poolAssetsLength != assetsValues.length) { + revert InvalidArguments(); + } + + for (uint256 j; j < poolAssetsLength; ) { + poolsAssetsDirectTransfer[comptrollers[i]][poolAssets[j]] = assetsValues[j]; + emit PoolAssetsDirectTransferUpdated(comptrollers[i], poolAssets[j], assetsValues[j]); + unchecked { + ++j; + } + } + + unchecked { + ++i; + } + } + } + /// @dev Update the reserve of the asset for the specific pool after transferring to risk fund /// and transferring funds to the protocol share reserve /// @param comptroller Comptroller address (pool) @@ -279,10 +348,11 @@ contract RiskFundConverter is AbstractTokenConverter { /// @return balanceDifference Amount of asset, for _privateConversion /// @custom:event AssetTransferredToDestination emits when poolsAssetsDirectTransfer is enabled for entered comptroller and asset /// @custom:error MarketNotExistInPool When asset does not exist in the pool(comptroller) - function _updateAssetsState( - address comptroller, - address asset - ) internal override returns (uint256 balanceDifference) { + function _updateAssetsState(address comptroller, address asset) + internal + override + returns (uint256 balanceDifference) + { if (!ensureAssetListed(comptroller, asset)) revert MarketNotExistInPool(comptroller, asset); IERC20Upgradeable token = IERC20Upgradeable(asset); diff --git a/contracts/TokenConverter/SingleTokenConverter.sol b/contracts/TokenConverter/SingleTokenConverter.sol index 175c39a0..e8661c20 100644 --- a/contracts/TokenConverter/SingleTokenConverter.sol +++ b/contracts/TokenConverter/SingleTokenConverter.sol @@ -18,6 +18,10 @@ contract SingleTokenConverter is AbstractTokenConverter { /// @notice Address of the base asset token address public baseAsset; + /// @notice The mapping contains the assets for each receiver which are sent to destination directly + /// @dev Direct Transfer Receiver -> Asset -> bool(should transfer directly on true) + mapping(address => mapping(address => bool)) public poolsAssetsDirectTransfer; + /// @notice Emitted when base asset is updated event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset); @@ -29,6 +33,9 @@ contract SingleTokenConverter is AbstractTokenConverter { uint256 amount ); + /// @notice Emitted after the poolsAssetsDirectTransfer mapping is updated + event PoolAssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value); + /// @dev Error thrown when only the destination address is allowed for direct transfer error OnlyDestinationAddressAllowedForDirectTransfer(); @@ -64,6 +71,21 @@ contract SingleTokenConverter is AbstractTokenConverter { _setBaseAsset(baseAsset_); } + /// @notice Update the poolsAssetsDirectTransfer mapping + /// @param receivers Addresses of the pools + /// @param assets Addresses of the assets need to be added for direct transfer + /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. + /// @custom:event PoolAssetsDirectTransferUpdated emits on success + /// @custom:access Restricted by ACM + function setPoolsAssetsDirectTransfer( + address[] calldata receivers, + address[][] calldata assets, + bool[][] calldata values + ) external virtual { + _checkAccessAllowed("setPoolsAssetsDirectTransfer(address[],address[][],bool[][])"); + _setPoolsAssetsDirectTransfer(receivers, assets, values); + } + /// @notice Get the balance for specific token /// @param tokenAddress Address of the token /// @return tokenBalance Balance of the token the contract has @@ -122,7 +144,7 @@ contract SingleTokenConverter is AbstractTokenConverter { address[] calldata receivers, address[][] calldata assets, bool[][] calldata values - ) internal override { + ) internal { uint256 receiversLength = receivers.length; uint256 destinationAddressIndex = 0; diff --git a/tests/TokenConverter/AbstractTokenConverter.ts b/tests/TokenConverter/AbstractTokenConverter.ts index 38ba9ada..8294a016 100644 --- a/tests/TokenConverter/AbstractTokenConverter.ts +++ b/tests/TokenConverter/AbstractTokenConverter.ts @@ -975,171 +975,6 @@ describe("MockConverter: tests", () => { }); }); - describe("Pools direct transfer", () => { - it("Revert on invalid access control", async () => { - await accessControl.isAllowedToCall.returns(false); - - await expect( - converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[true]]), - ).to.be.revertedWithCustomError(converter, "Unauthorized"); - }); - - it("Success on the setPoolsAssetsDirectTransfer", async () => { - await accessControl.isAllowedToCall.returns(true); - - await expect(converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[true]])) - .to.emit(converter, "PoolAssetsDirectTransferUpdated") - .withArgs(comptroller.address, tokenIn.address, true); - - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(true); - }); - - it("Success on setting multiple pools and assets", async () => { - await accessControl.isAllowedToCall.returns(true); - - const [, , poolB] = await ethers.getSigners(); - - await expect( - converter.setPoolsAssetsDirectTransfer( - [comptroller.address, poolB.address], - [[tokenIn.address, tokenOut.address], [tokenIn.address]], - [[true, false], [true]], - ), - ) - .to.emit(converter, "PoolAssetsDirectTransferUpdated") - .withArgs(comptroller.address, tokenIn.address, true) - .to.emit(converter, "PoolAssetsDirectTransferUpdated") - .withArgs(comptroller.address, tokenOut.address, false) - .to.emit(converter, "PoolAssetsDirectTransferUpdated") - .withArgs(poolB.address, tokenIn.address, true); - - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(true); - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenOut.address)).to.equal(false); - expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenIn.address)).to.equal(true); - }); - - it("Revert on invalid parameters - comptrollers and assets length mismatch", async () => { - await accessControl.isAllowedToCall.returns(true); - - const [, , poolB] = await ethers.getSigners(); - - await expect( - converter.setPoolsAssetsDirectTransfer( - [comptroller.address, poolB.address], - [[tokenIn.address]], - [[true], [true]], - ), - ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); - }); - - it("Revert on invalid parameters - comptrollers and values length mismatch", async () => { - await accessControl.isAllowedToCall.returns(true); - - await expect( - converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[true], [false]]), - ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); - }); - - it("Revert on invalid parameters - assets and values nested array length mismatch", async () => { - await accessControl.isAllowedToCall.returns(true); - - await expect( - converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address, tokenOut.address]], [[true]]), - ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); - }); - - it("Update existing poolsAssetsDirectTransfer mapping", async () => { - await accessControl.isAllowedToCall.returns(true); - - await converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[true]]); - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(true); - - await expect(converter.setPoolsAssetsDirectTransfer([comptroller.address], [[tokenIn.address]], [[false]])) - .to.emit(converter, "PoolAssetsDirectTransferUpdated") - .withArgs(comptroller.address, tokenIn.address, false); - - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(false); - }); - - it("Handle empty arrays correctly", async () => { - await accessControl.isAllowedToCall.returns(true); - - await converter.setPoolsAssetsDirectTransfer([], [], []); - - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(false); - }); - - it("Verify poolsAssetsDirectTransfer mapping getter returns correct values", async () => { - await accessControl.isAllowedToCall.returns(true); - - const [, , poolB, poolC] = await ethers.getSigners(); - - await converter.setPoolsAssetsDirectTransfer( - [comptroller.address, poolB.address, poolC.address], - [[tokenIn.address, tokenOut.address], [tokenIn.address], [tokenOut.address]], - [[true, false], [false], [true]], - ); - - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(true); - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenOut.address)).to.equal(false); - expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenIn.address)).to.equal(false); - expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenOut.address)).to.equal(false); - expect(await converter.poolsAssetsDirectTransfer(poolC.address, tokenIn.address)).to.equal(false); - expect(await converter.poolsAssetsDirectTransfer(poolC.address, tokenOut.address)).to.equal(true); - }); - - it("Verify multiple batch operations work correctly", async () => { - await accessControl.isAllowedToCall.returns(true); - - const [, , poolB, poolC, poolD] = await ethers.getSigners(); - - // First batch - await converter.setPoolsAssetsDirectTransfer( - [comptroller.address, poolB.address], - [[tokenIn.address], [tokenOut.address, tokenOut2.address]], - [[true], [true, false]], - ); - - // Second batch - should update existing and add new - await converter.setPoolsAssetsDirectTransfer( - [comptroller.address, poolC.address, poolD.address], - [[tokenIn.address, tokenOut.address], [tokenIn.address], [tokenOut2.address]], - [[false, true], [true], [true]], - ); - - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenIn.address)).to.equal(false); - expect(await converter.poolsAssetsDirectTransfer(comptroller.address, tokenOut.address)).to.equal(true); - expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenOut.address)).to.equal(true); - expect(await converter.poolsAssetsDirectTransfer(poolB.address, tokenOut2.address)).to.equal(false); - expect(await converter.poolsAssetsDirectTransfer(poolC.address, tokenIn.address)).to.equal(true); - expect(await converter.poolsAssetsDirectTransfer(poolD.address, tokenOut2.address)).to.equal(true); - }); - - it("Verify events are emitted for all changes in batch operations", async () => { - await accessControl.isAllowedToCall.returns(true); - - const [, , poolB] = await ethers.getSigners(); - - const tx = await converter.setPoolsAssetsDirectTransfer( - [comptroller.address, poolB.address], - [[tokenIn.address, tokenOut.address], [tokenOut2.address]], - [[true, false], [true]], - ); - - await expect(tx) - .to.emit(converter, "PoolAssetsDirectTransferUpdated") - .withArgs(comptroller.address, tokenIn.address, true); - - await expect(tx) - .to.emit(converter, "PoolAssetsDirectTransferUpdated") - .withArgs(comptroller.address, tokenOut.address, false); - - await expect(tx) - .to.emit(converter, "PoolAssetsDirectTransferUpdated") - .withArgs(poolB.address, tokenOut2.address, true); - }); - }); - describe("Private conversion: tests", () => { beforeEach(async () => { await destination.convertibleBaseAsset.returns(tokenIn.address); diff --git a/tests/TokenConverter/RiskFundConverter.ts b/tests/TokenConverter/RiskFundConverter.ts index 3b2f765b..156ce16b 100644 --- a/tests/TokenConverter/RiskFundConverter.ts +++ b/tests/TokenConverter/RiskFundConverter.ts @@ -265,19 +265,19 @@ describe("Risk fund Converter: tests", () => { [[tokenIn.address], [tokenIn.address]], [[true]], ), - ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + ).to.be.revertedWithCustomError(converter, "InvalidArguments"); await expect( converter.setPoolsAssetsDirectTransfer([poolA.address], [[tokenIn.address], [tokenIn.address]], [[true]]), - ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + ).to.be.revertedWithCustomError(converter, "InvalidArguments"); await expect( converter.setPoolsAssetsDirectTransfer([poolA.address], [[tokenIn.address, tokenIn.address]], [[true]]), - ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + ).to.be.revertedWithCustomError(converter, "InvalidArguments"); await expect( converter.setPoolsAssetsDirectTransfer([poolA.address], [[tokenIn.address]], [[true, true]]), - ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); + ).to.be.revertedWithCustomError(converter, "InvalidArguments"); }); }); From 163224d57423fbc655b3d253ec43f3b048d63ef1 Mon Sep 17 00:00:00 2001 From: Filip Malachowicz Date: Mon, 4 Aug 2025 10:14:56 +0200 Subject: [PATCH 03/15] feat: SingleTokenConverter always directly transfers assets to destinationAddress --- .../TokenConverter/RiskFundConverter.sol | 1 - .../TokenConverter/SingleTokenConverter.sol | 68 ++++++------------- tests/TokenConverter/SingleTokenConverter.ts | 57 +++------------- 3 files changed, 29 insertions(+), 97 deletions(-) diff --git a/contracts/TokenConverter/RiskFundConverter.sol b/contracts/TokenConverter/RiskFundConverter.sol index 299c7736..9ce0815a 100644 --- a/contracts/TokenConverter/RiskFundConverter.sol +++ b/contracts/TokenConverter/RiskFundConverter.sol @@ -362,7 +362,6 @@ contract RiskFundConverter is AbstractTokenConverter { unchecked { balanceDifference = currentBalance - assetReserve; } - if (poolsAssetsDirectTransfer[comptroller][asset]) { uint256 previousDestinationBalance = token.balanceOf(destinationAddress); token.safeTransfer(destinationAddress, balanceDifference); diff --git a/contracts/TokenConverter/SingleTokenConverter.sol b/contracts/TokenConverter/SingleTokenConverter.sol index e8661c20..afd7091c 100644 --- a/contracts/TokenConverter/SingleTokenConverter.sol +++ b/contracts/TokenConverter/SingleTokenConverter.sol @@ -18,9 +18,9 @@ contract SingleTokenConverter is AbstractTokenConverter { /// @notice Address of the base asset token address public baseAsset; - /// @notice The mapping contains the assets for each receiver which are sent to destination directly - /// @dev Direct Transfer Receiver -> Asset -> bool(should transfer directly on true) - mapping(address => mapping(address => bool)) public poolsAssetsDirectTransfer; + /// @notice The mapping contains the assets which are sent to destination directly + /// @dev Asset -> bool(should transfer directly on true) + mapping(address => bool) public assetsDirectTransfer; /// @notice Emitted when base asset is updated event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset); @@ -33,11 +33,8 @@ contract SingleTokenConverter is AbstractTokenConverter { uint256 amount ); - /// @notice Emitted after the poolsAssetsDirectTransfer mapping is updated - event PoolAssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value); - - /// @dev Error thrown when only the destination address is allowed for direct transfer - error OnlyDestinationAddressAllowedForDirectTransfer(); + /// @notice Emitted after the assetsDirectTransfer mapping is updated + event AssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value); /// @custom:oz-upgrades-unsafe-allow constructor constructor() { @@ -71,19 +68,14 @@ contract SingleTokenConverter is AbstractTokenConverter { _setBaseAsset(baseAsset_); } - /// @notice Update the poolsAssetsDirectTransfer mapping - /// @param receivers Addresses of the pools + /// @notice Update the assetsDirectTransfer mapping /// @param assets Addresses of the assets need to be added for direct transfer /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. - /// @custom:event PoolAssetsDirectTransferUpdated emits on success + /// @custom:event AssetsDirectTransferUpdated emits on success /// @custom:access Restricted by ACM - function setPoolsAssetsDirectTransfer( - address[] calldata receivers, - address[][] calldata assets, - bool[][] calldata values - ) external virtual { - _checkAccessAllowed("setPoolsAssetsDirectTransfer(address[],address[][],bool[][])"); - _setPoolsAssetsDirectTransfer(receivers, assets, values); + function setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) external virtual { + _checkAccessAllowed("setAssetsDirectTransfer(address[],bool[])"); + _setAssetsDirectTransfer(assets, values); } /// @notice Get the balance for specific token @@ -103,7 +95,7 @@ contract SingleTokenConverter is AbstractTokenConverter { uint256 balance = token.balanceOf(address(this)); balanceLeft = balance; - if (asset == baseAsset || poolsAssetsDirectTransfer[destinationAddress][asset]) { + if (asset == baseAsset || assetsDirectTransfer[asset]) { balanceLeft = 0; token.safeTransfer(destinationAddress, balance); emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance); @@ -134,43 +126,23 @@ contract SingleTokenConverter is AbstractTokenConverter { } } - /// @dev Override to only allow setting poolsAssetsDirectTransfer for destinationAddress + /// @dev Update the assetsDirectTransfer mapping for destinationAddress /// @param assets Addresses of the assets need to be added for direct transfer /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. - /// @custom:event PoolAssetsDirectTransferUpdated emits on success - /// @custom:error OnlyDestinationAddressAllowedForDirectTransfer is thrown when receivers array is not an array of one element equal to the destination address + /// @custom:event AssetsDirectTransferUpdated emits on success /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match - function _setPoolsAssetsDirectTransfer( - address[] calldata receivers, - address[][] calldata assets, - bool[][] calldata values - ) internal { - uint256 receiversLength = receivers.length; - uint256 destinationAddressIndex = 0; - - // Ensure that the destinationAddress is the only receiver - if (receiversLength != 1 || receivers[destinationAddressIndex] != destinationAddress) { - revert OnlyDestinationAddressAllowedForDirectTransfer(); - } - - if ((receiversLength != assets.length) || (receiversLength != values.length)) { - revert InputLengthMisMatch(); - } - - address[] memory poolAssets = assets[destinationAddressIndex]; - bool[] memory assetsValues = values[destinationAddressIndex]; - uint256 poolAssetsLength = poolAssets.length; + function _setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) internal { + uint256 assetsLength = assets.length; - if (poolAssetsLength != assetsValues.length) { + if (assetsLength != values.length) { revert InputLengthMisMatch(); } - for (uint256 j; j < poolAssetsLength; ) { - // Always use destinationAddress as the direct transfer receiver address - poolsAssetsDirectTransfer[destinationAddress][poolAssets[j]] = assetsValues[j]; - emit PoolAssetsDirectTransferUpdated(destinationAddress, poolAssets[j], assetsValues[j]); + for (uint256 i; i < assetsLength; ) { + assetsDirectTransfer[assets[i]] = values[i]; + emit AssetsDirectTransferUpdated(destinationAddress, assets[i], values[i]); unchecked { - ++j; + ++i; } } } diff --git a/tests/TokenConverter/SingleTokenConverter.ts b/tests/TokenConverter/SingleTokenConverter.ts index 22c28f8d..fc29e2ab 100644 --- a/tests/TokenConverter/SingleTokenConverter.ts +++ b/tests/TokenConverter/SingleTokenConverter.ts @@ -126,27 +126,23 @@ describe("XVS vault Converter: tests", () => { }); }); - describe("Whitelisted tokens direct transfer", () => { + describe("Assets direct transfer", () => { it("Revert on invalid access control", async () => { await accessControl.isAllowedToCall.returns(false); await expect( - converter.setPoolsAssetsDirectTransfer([xvsVaultTreasury.address], [[whitelistedTokenIn.address]], [[true]]), + converter.setAssetsDirectTransfer([whitelistedTokenIn.address], [true]), ).to.be.revertedWithCustomError(converter, "Unauthorized"); }); - it("Success on the setPoolsAssetsDirectTransfer", async () => { + it("Success on the setAssetsDirectTransfer", async () => { await accessControl.isAllowedToCall.returns(true); - await expect( - converter.setPoolsAssetsDirectTransfer([xvsVaultTreasury.address], [[whitelistedTokenIn.address]], [[true]]), - ) - .to.emit(converter, "PoolAssetsDirectTransferUpdated") + await expect(converter.setAssetsDirectTransfer([whitelistedTokenIn.address], [true])) + .to.emit(converter, "AssetsDirectTransferUpdated") .withArgs(xvsVaultTreasury.address, whitelistedTokenIn.address, true); - expect(await converter.poolsAssetsDirectTransfer(xvsVaultTreasury.address, whitelistedTokenIn.address)).to.equal( - true, - ); + expect(await converter.assetsDirectTransfer(whitelistedTokenIn.address)).to.equal(true); }); it("Transfer funds to treasury directly when using whitelisted token", async () => { @@ -156,57 +152,22 @@ describe("XVS vault Converter: tests", () => { expect(await whitelistedTokenIn.balanceOf(xvsVaultTreasury.address)).to.equal(0); expect(await whitelistedTokenIn.balanceOf(converter.address)).to.equal(0); await whitelistedTokenIn.transfer(converter.address, whitelistedTokenAmount); - await converter.setPoolsAssetsDirectTransfer( - [xvsVaultTreasury.address], - [[whitelistedTokenIn.address]], - [[true]], - ); + await converter.setAssetsDirectTransfer([whitelistedTokenIn.address], [true]); await converter.updateAssetsState(fakeComptroller.address, whitelistedTokenIn.address); expect(await whitelistedTokenIn.balanceOf(converter.address)).to.equal(0); expect(await whitelistedTokenIn.balanceOf(xvsVaultTreasury.address)).to.equal(whitelistedTokenAmount); }); - it("Revert on when trying to set to a differnet address than xvsVaultTreasury", async () => { - await accessControl.isAllowedToCall.returns(true); - await expect( - converter.setPoolsAssetsDirectTransfer([whitelistedTokenIn.address], [[whitelistedTokenIn.address]], [[true]]), - ).to.be.revertedWithCustomError(converter, "OnlyDestinationAddressAllowedForDirectTransfer"); - - await expect( - converter.setPoolsAssetsDirectTransfer( - [xvsVaultTreasury.address, xvsVaultTreasury.address], - [[whitelistedTokenIn.address], [whitelistedTokenIn.address]], - [[true]], - ), - ).to.be.revertedWithCustomError(converter, "OnlyDestinationAddressAllowedForDirectTransfer"); - }); - it("Revert on invalid parameters lengths", async () => { await accessControl.isAllowedToCall.returns(true); await expect( - converter.setPoolsAssetsDirectTransfer( - [xvsVaultTreasury.address], - [[whitelistedTokenIn.address], [whitelistedTokenIn.address]], - [[true]], - ), - ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); - - await expect( - converter.setPoolsAssetsDirectTransfer( - [xvsVaultTreasury.address], - [[whitelistedTokenIn.address, whitelistedTokenIn.address]], - [[true]], - ), + converter.setAssetsDirectTransfer([whitelistedTokenIn.address, whitelistedTokenIn.address], [true]), ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); await expect( - converter.setPoolsAssetsDirectTransfer( - [xvsVaultTreasury.address], - [[whitelistedTokenIn.address]], - [[true, true]], - ), + converter.setAssetsDirectTransfer([whitelistedTokenIn.address], [true, true]), ).to.be.revertedWithCustomError(converter, "InputLengthMisMatch"); }); }); From b7cbe7c1d01e0594616fe3743a16ed85e9b52119 Mon Sep 17 00:00:00 2001 From: Filip Malachowicz Date: Mon, 4 Aug 2025 11:10:07 +0200 Subject: [PATCH 04/15] feat: after review changes --- .../TokenConverter/SingleTokenConverter.sol | 8 ++++++++ tests/TokenConverter/SingleTokenConverter.ts | 17 +++++------------ 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/contracts/TokenConverter/SingleTokenConverter.sol b/contracts/TokenConverter/SingleTokenConverter.sol index afd7091c..103a5680 100644 --- a/contracts/TokenConverter/SingleTokenConverter.sol +++ b/contracts/TokenConverter/SingleTokenConverter.sol @@ -36,6 +36,9 @@ contract SingleTokenConverter is AbstractTokenConverter { /// @notice Emitted after the assetsDirectTransfer mapping is updated event AssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value); + /// @notice Thrown when the base asset is the same as the new base asset + error SameBaseAssetNotAllowed(); + /// @custom:oz-upgrades-unsafe-allow constructor constructor() { // Note that the contract is upgradeable. Use initialize() or reinitializers @@ -153,6 +156,11 @@ contract SingleTokenConverter is AbstractTokenConverter { /// @custom:event BaseAssetUpdated is emitted on success function _setBaseAsset(address baseAsset_) internal { ensureNonzeroAddress(baseAsset_); + + if (baseAsset == baseAsset_) { + revert SameBaseAssetNotAllowed(); + } + emit BaseAssetUpdated(baseAsset, baseAsset_); baseAsset = baseAsset_; } diff --git a/tests/TokenConverter/SingleTokenConverter.ts b/tests/TokenConverter/SingleTokenConverter.ts index fc29e2ab..6d204c51 100644 --- a/tests/TokenConverter/SingleTokenConverter.ts +++ b/tests/TokenConverter/SingleTokenConverter.ts @@ -180,13 +180,6 @@ describe("XVS vault Converter: tests", () => { ); }); - it("Should revert on zero address", async () => { - await expect(converter.setBaseAsset(ethers.constants.AddressZero)).to.be.revertedWithCustomError( - converter, - "ZeroAddressNotAllowed", - ); - }); - it("Should succeed on updating existing base asset", async () => { await converter.setBaseAsset(tokenIn.address); expect(await converter.baseAsset()).to.equal(tokenIn.address); @@ -197,14 +190,14 @@ describe("XVS vault Converter: tests", () => { expect(await converter.baseAsset()).to.equal(tokenOut.address); }); - it("Should succeed on setting same base asset multiple times", async () => { + it("Should revert on setting same base asset multiple times", async () => { await converter.setBaseAsset(tokenIn.address); expect(await converter.baseAsset()).to.equal(tokenIn.address); - const tx = await converter.setBaseAsset(tokenIn.address); - expect(tx).to.emit(converter, "BaseAssetUpdated").withArgs(tokenIn.address, tokenIn.address); - - expect(await converter.baseAsset()).to.equal(tokenIn.address); + await expect(converter.setBaseAsset(tokenIn.address)).to.be.revertedWithCustomError( + converter, + "SameBaseAssetNotAllowed", + ); }); }); From 868c4dc97a15d2b920ea7cecba562c3488ed8ff9 Mon Sep 17 00:00:00 2001 From: Filip Malachowicz Date: Mon, 4 Aug 2025 11:42:42 +0200 Subject: [PATCH 05/15] fix: missing natspec comment --- contracts/TokenConverter/SingleTokenConverter.sol | 1 + 1 file changed, 1 insertion(+) diff --git a/contracts/TokenConverter/SingleTokenConverter.sol b/contracts/TokenConverter/SingleTokenConverter.sol index 103a5680..26e0db7d 100644 --- a/contracts/TokenConverter/SingleTokenConverter.sol +++ b/contracts/TokenConverter/SingleTokenConverter.sol @@ -153,6 +153,7 @@ contract SingleTokenConverter is AbstractTokenConverter { /// @dev Sets the base asset for the contract /// @param baseAsset_ The new address of the base asset /// @custom:error ZeroAddressNotAllowed is thrown when address is zero + /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset /// @custom:event BaseAssetUpdated is emitted on success function _setBaseAsset(address baseAsset_) internal { ensureNonzeroAddress(baseAsset_); From d3bcf379b3f16e912fd2bb01004870d65f80beca Mon Sep 17 00:00:00 2001 From: Jesus Lanchas Date: Mon, 11 Aug 2025 09:24:07 +0200 Subject: [PATCH 06/15] fix: vsw-05 --- contracts/TokenConverter/SingleTokenConverter.sol | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/contracts/TokenConverter/SingleTokenConverter.sol b/contracts/TokenConverter/SingleTokenConverter.sol index 26e0db7d..5441a5f9 100644 --- a/contracts/TokenConverter/SingleTokenConverter.sol +++ b/contracts/TokenConverter/SingleTokenConverter.sol @@ -141,12 +141,9 @@ contract SingleTokenConverter is AbstractTokenConverter { revert InputLengthMisMatch(); } - for (uint256 i; i < assetsLength; ) { + for (uint256 i; i < assetsLength; ++i) { assetsDirectTransfer[assets[i]] = values[i]; emit AssetsDirectTransferUpdated(destinationAddress, assets[i], values[i]); - unchecked { - ++i; - } } } From 18bd5394e3599e9af0af162b402b96567a02fb5a Mon Sep 17 00:00:00 2001 From: Jesus Lanchas Date: Mon, 11 Aug 2025 09:28:26 +0200 Subject: [PATCH 07/15] docs: vsw-04 --- contracts/TokenConverter/SingleTokenConverter.sol | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/contracts/TokenConverter/SingleTokenConverter.sol b/contracts/TokenConverter/SingleTokenConverter.sol index 5441a5f9..d2deaafd 100644 --- a/contracts/TokenConverter/SingleTokenConverter.sol +++ b/contracts/TokenConverter/SingleTokenConverter.sol @@ -66,6 +66,9 @@ contract SingleTokenConverter is AbstractTokenConverter { /// @notice Sets the base asset for the contract /// @param baseAsset_ The new address of the base asset + /// @custom:error ZeroAddressNotAllowed is thrown when address is zero + /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset + /// @custom:event BaseAssetUpdated is emitted on success /// @custom:access Only Governance function setBaseAsset(address baseAsset_) external onlyOwner { _setBaseAsset(baseAsset_); @@ -75,6 +78,7 @@ contract SingleTokenConverter is AbstractTokenConverter { /// @param assets Addresses of the assets need to be added for direct transfer /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. /// @custom:event AssetsDirectTransferUpdated emits on success + /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match /// @custom:access Restricted by ACM function setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) external virtual { _checkAccessAllowed("setAssetsDirectTransfer(address[],bool[])"); From 416d0259c7ef34e5cddacdd006e338bcd62ba0dc Mon Sep 17 00:00:00 2001 From: Jesus Lanchas Date: Mon, 11 Aug 2025 09:49:57 +0200 Subject: [PATCH 08/15] docs: vsw-03 --- contracts/TokenConverter/SingleTokenConverter.sol | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/contracts/TokenConverter/SingleTokenConverter.sol b/contracts/TokenConverter/SingleTokenConverter.sol index d2deaafd..160b50e2 100644 --- a/contracts/TokenConverter/SingleTokenConverter.sol +++ b/contracts/TokenConverter/SingleTokenConverter.sol @@ -75,7 +75,7 @@ contract SingleTokenConverter is AbstractTokenConverter { } /// @notice Update the assetsDirectTransfer mapping - /// @param assets Addresses of the assets need to be added for direct transfer + /// @param assets Addresses of the assets need to be added or removed for direct transfer /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. /// @custom:event AssetsDirectTransferUpdated emits on success /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match @@ -93,10 +93,12 @@ contract SingleTokenConverter is AbstractTokenConverter { tokenBalance = token.balanceOf(address(this)); } + /// @dev It returns the balance of the `asset` in this contract. If `asset` is the `baseAsset` + /// or `assetsDirectTransfer[asset]` is true, then the balance of `asset` in this contract will + /// be transferred to the `destinationAddress` and 0 will be returned /// @param comptroller Comptroller address (pool) /// @param asset Asset address. /// @return balanceLeft Amount of asset, for _privateConversion - // solhint-disable-next-line function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) { IERC20Upgradeable token = IERC20Upgradeable(asset); uint256 balance = token.balanceOf(address(this)); @@ -134,7 +136,7 @@ contract SingleTokenConverter is AbstractTokenConverter { } /// @dev Update the assetsDirectTransfer mapping for destinationAddress - /// @param assets Addresses of the assets need to be added for direct transfer + /// @param assets Addresses of the assets need to be added or removed for direct transfer /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. /// @custom:event AssetsDirectTransferUpdated emits on success /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match From abc97271b6b81979a2021cbc7bde4a5a7da85dad Mon Sep 17 00:00:00 2001 From: Jesus Lanchas Date: Mon, 11 Aug 2025 10:31:47 +0200 Subject: [PATCH 09/15] fix: vsw-02 --- .../TokenConverter/SingleTokenConverter.sol | 19 ++++++ tests/TokenConverter/SingleTokenConverter.ts | 66 +++++++++++-------- 2 files changed, 56 insertions(+), 29 deletions(-) diff --git a/contracts/TokenConverter/SingleTokenConverter.sol b/contracts/TokenConverter/SingleTokenConverter.sol index 160b50e2..aadf323a 100644 --- a/contracts/TokenConverter/SingleTokenConverter.sol +++ b/contracts/TokenConverter/SingleTokenConverter.sol @@ -39,6 +39,14 @@ contract SingleTokenConverter is AbstractTokenConverter { /// @notice Thrown when the base asset is the same as the new base asset error SameBaseAssetNotAllowed(); + /// @notice Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection + error DirectTransferBaseAssetNotAllowed(); + + /// @notice Thrown when the `assetsDirectTransfer[asset]` is already `value` + /// @param asset The asset address whose `assetDirectTransfer` value went to be set + /// @param value The value to be set + error SameAssetDirectTransferNotAllowed(address asset, bool value); + /// @custom:oz-upgrades-unsafe-allow constructor constructor() { // Note that the contract is upgradeable. Use initialize() or reinitializers @@ -140,6 +148,9 @@ contract SingleTokenConverter is AbstractTokenConverter { /// @param values Boolean value to indicate whether direct transfer is allowed for each asset. /// @custom:event AssetsDirectTransferUpdated emits on success /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match + /// @custom:error DirectTransferBaseAssetNotAllowed thrown when an asset in `assets` is the `baseAsset` + /// @custom:error SameAssetDirectTransferNotAllowed thrown when the value to set for an asset doesn't differs + /// from its current value function _setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) internal { uint256 assetsLength = assets.length; @@ -148,6 +159,14 @@ contract SingleTokenConverter is AbstractTokenConverter { } for (uint256 i; i < assetsLength; ++i) { + if (assets[i] == baseAsset) { + revert DirectTransferBaseAssetNotAllowed(); + } + + if (assetsDirectTransfer[assets[i]] == values[i]) { + revert SameAssetDirectTransferNotAllowed(assets[i], values[i]); + } + assetsDirectTransfer[assets[i]] = values[i]; emit AssetsDirectTransferUpdated(destinationAddress, assets[i], values[i]); } diff --git a/tests/TokenConverter/SingleTokenConverter.ts b/tests/TokenConverter/SingleTokenConverter.ts index 6d204c51..00c95d69 100644 --- a/tests/TokenConverter/SingleTokenConverter.ts +++ b/tests/TokenConverter/SingleTokenConverter.ts @@ -117,6 +117,16 @@ describe("XVS vault Converter: tests", () => { ); }); + it("Should revert on setting same base asset multiple times", async () => { + await converter.setBaseAsset(tokenIn.address); + expect(await converter.baseAsset()).to.equal(tokenIn.address); + + await expect(converter.setBaseAsset(tokenIn.address)).to.be.revertedWithCustomError( + converter, + "SameBaseAssetNotAllowed", + ); + }); + it("Should set base asset successfully", async () => { const [, unknownAddress] = await ethers.getSigners(); @@ -124,6 +134,16 @@ describe("XVS vault Converter: tests", () => { .to.emit(converter, "BaseAssetUpdated") .withArgs(xvs.address, unknownAddress.address); }); + + it("Should succeed on updating existing base asset", async () => { + await converter.setBaseAsset(tokenIn.address); + expect(await converter.baseAsset()).to.equal(tokenIn.address); + + const tx = await converter.setBaseAsset(tokenOut.address); + expect(tx).to.emit(converter, "BaseAssetUpdated").withArgs(tokenIn.address, tokenOut.address); + + expect(await converter.baseAsset()).to.equal(tokenOut.address); + }); }); describe("Assets direct transfer", () => { @@ -135,6 +155,23 @@ describe("XVS vault Converter: tests", () => { ).to.be.revertedWithCustomError(converter, "Unauthorized"); }); + it("Revert when the asset is the base asset", async () => { + await accessControl.isAllowedToCall.returns(true); + await converter.setBaseAsset(whitelistedTokenIn.address); + + await expect( + converter.setAssetsDirectTransfer([whitelistedTokenIn.address], [true]), + ).to.be.revertedWithCustomError(converter, "DirectTransferBaseAssetNotAllowed"); + }); + + it("Revert then value to set is the current value", async () => { + await accessControl.isAllowedToCall.returns(true); + await converter.setAssetsDirectTransfer([whitelistedTokenIn.address], [true]), + await expect( + converter.setAssetsDirectTransfer([whitelistedTokenIn.address], [true]), + ).to.be.revertedWithCustomError(converter, "SameAssetDirectTransferNotAllowed"); + }); + it("Success on the setAssetsDirectTransfer", async () => { await accessControl.isAllowedToCall.returns(true); @@ -172,35 +209,6 @@ describe("XVS vault Converter: tests", () => { }); }); - describe("setBaseAsset", () => { - it("Should revert on non-owner call", async () => { - const [, user] = await ethers.getSigners(); - await expect(converter.connect(user).setBaseAsset(tokenIn.address)).to.be.revertedWith( - "Ownable: caller is not the owner", - ); - }); - - it("Should succeed on updating existing base asset", async () => { - await converter.setBaseAsset(tokenIn.address); - expect(await converter.baseAsset()).to.equal(tokenIn.address); - - const tx = await converter.setBaseAsset(tokenOut.address); - expect(tx).to.emit(converter, "BaseAssetUpdated").withArgs(tokenIn.address, tokenOut.address); - - expect(await converter.baseAsset()).to.equal(tokenOut.address); - }); - - it("Should revert on setting same base asset multiple times", async () => { - await converter.setBaseAsset(tokenIn.address); - expect(await converter.baseAsset()).to.equal(tokenIn.address); - - await expect(converter.setBaseAsset(tokenIn.address)).to.be.revertedWithCustomError( - converter, - "SameBaseAssetNotAllowed", - ); - }); - }); - describe("balanceOf", () => { it("Should return zero for token not in contract", async () => { expect(await converter.balanceOf(tokenIn.address)).to.equal(0); From 21031d3e5fde68a3e33995a0c01f3350f4370c96 Mon Sep 17 00:00:00 2001 From: Filip Malachowicz Date: Wed, 20 Aug 2025 10:27:57 +0200 Subject: [PATCH 10/15] feat: deploy to arbitrumone, bscmainnet, bsctestnet --- ...e-single-token-converter-implementation.ts | 21 ++ .../arbitrumone/SingleTokenConverterImp.json | 197 ++++++++++++++++-- .../dceb6d0de70f90933a7f2cdf26a987ca.json | 103 +++++++++ .../bscmainnet/SingleTokenConverterImp.json | 197 ++++++++++++++++-- .../dceb6d0de70f90933a7f2cdf26a987ca.json | 103 +++++++++ .../bsctestnet/SingleTokenConverterImp.json | 191 +++++++++++++++-- .../dceb6d0de70f90933a7f2cdf26a987ca.json | 103 +++++++++ 7 files changed, 852 insertions(+), 63 deletions(-) create mode 100644 deploy/006-update-single-token-converter-implementation.ts create mode 100644 deployments/arbitrumone/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json create mode 100644 deployments/bscmainnet/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json create mode 100644 deployments/bsctestnet/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json diff --git a/deploy/006-update-single-token-converter-implementation.ts b/deploy/006-update-single-token-converter-implementation.ts new file mode 100644 index 00000000..2b82d3d8 --- /dev/null +++ b/deploy/006-update-single-token-converter-implementation.ts @@ -0,0 +1,21 @@ +import { DeployFunction } from "hardhat-deploy/types"; +import { HardhatRuntimeEnvironment } from "hardhat/types"; + +const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) { + const { deployments, getNamedAccounts } = hre; + const { deploy } = deployments; + const { deployer } = await getNamedAccounts(); + + await deploy("SingleTokenConverterImp", { + contract: "SingleTokenConverter", + from: deployer, + args: [], + log: true, + autoMine: true, + skipIfAlreadyDeployed: false, + }); +}; + +func.tags = ["SingleTokenConverterImpl"]; + +export default func; diff --git a/deployments/arbitrumone/SingleTokenConverterImp.json b/deployments/arbitrumone/SingleTokenConverterImp.json index fc197ef9..cf24728c 100644 --- a/deployments/arbitrumone/SingleTokenConverterImp.json +++ b/deployments/arbitrumone/SingleTokenConverterImp.json @@ -1,5 +1,5 @@ { - "address": "0x2EE413F4e060451CB25AeD5Cdd348F430aa79105", + "address": "0x28519f39Ce3e01449Bb8aFDdC6b94F32F3d7d1bd", "abi": [ { "inputs": [], @@ -73,6 +73,11 @@ "name": "DeflationaryTokenNotSupported", "type": "error" }, + { + "inputs": [], + "name": "DirectTransferBaseAssetNotAllowed", + "type": "error" + }, { "inputs": [ { @@ -134,6 +139,27 @@ "name": "NonZeroIncentiveForPrivateConversion", "type": "error" }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "bool", + "name": "value", + "type": "bool" + } + ], + "name": "SameAssetDirectTransferNotAllowed", + "type": "error" + }, + { + "inputs": [], + "name": "SameBaseAssetNotAllowed", + "type": "error" + }, { "inputs": [ { @@ -196,6 +222,31 @@ "name": "AssetTransferredToDestination", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "value", + "type": "bool" + } + ], + "name": "AssetsDirectTransferUpdated", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -660,6 +711,25 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "assetsDirectTransfer", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [ { @@ -1191,6 +1261,24 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "assets", + "type": "address[]" + }, + { + "internalType": "bool[]", + "name": "values", + "type": "bool[]" + } + ], + "name": "setAssetsDirectTransfer", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -1381,42 +1469,52 @@ "type": "function" } ], - "transactionHash": "0xe6dc29e0bb4e27310d731c350bae94b7f43edf3a68926e473fb7a4a8cebb0c97", + "transactionHash": "0xcb9bb717c7f3455851ae4fbf881d02cb0b455fe0e40e4c55c6de95e87e3b10c3", "receipt": { "to": null, - "from": "0x2A94EAb15be8557e6dDAE87eCeCf69ba58aAE2AD", - "contractAddress": "0x2EE413F4e060451CB25AeD5Cdd348F430aa79105", - "transactionIndex": 1, - "gasUsed": "4216061", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000080000000010000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0xf91298ce4a53fab75ddac32e16ddf6f6abdaf10ce8858e75a22c227b23ad95a0", - "transactionHash": "0xe6dc29e0bb4e27310d731c350bae94b7f43edf3a68926e473fb7a4a8cebb0c97", + "from": "0x3c977230b38B45D040a6a206E12eb441F58D88C7", + "contractAddress": "0x28519f39Ce3e01449Bb8aFDdC6b94F32F3d7d1bd", + "transactionIndex": 4, + "gasUsed": "4040648", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000400000000000020000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000", + "blockHash": "0x0364a214f4c448996cc4c8acb053157c17669e981ec7915a53a36b9e8adc66f6", + "transactionHash": "0xcb9bb717c7f3455851ae4fbf881d02cb0b455fe0e40e4c55c6de95e87e3b10c3", "logs": [ { - "transactionIndex": 1, - "blockNumber": 356224710, - "transactionHash": "0xe6dc29e0bb4e27310d731c350bae94b7f43edf3a68926e473fb7a4a8cebb0c97", - "address": "0x2EE413F4e060451CB25AeD5Cdd348F430aa79105", + "transactionIndex": 4, + "blockNumber": 370349297, + "transactionHash": "0xcb9bb717c7f3455851ae4fbf881d02cb0b455fe0e40e4c55c6de95e87e3b10c3", + "address": "0x28519f39Ce3e01449Bb8aFDdC6b94F32F3d7d1bd", "topics": ["0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498"], "data": "0x00000000000000000000000000000000000000000000000000000000000000ff", - "logIndex": 0, - "blockHash": "0xf91298ce4a53fab75ddac32e16ddf6f6abdaf10ce8858e75a22c227b23ad95a0" + "logIndex": 9, + "blockHash": "0x0364a214f4c448996cc4c8acb053157c17669e981ec7915a53a36b9e8adc66f6" } ], - "blockNumber": 356224710, - "cumulativeGasUsed": "4216061", + "blockNumber": 370349297, + "cumulativeGasUsed": "4442897", "status": 1, "byzantium": true }, "args": [], - "numDeployments": 2, - "solcInputHash": "e2c9962896c0d2548025c54c4fbe3c77", - "metadata": "{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountInHigherThanMax\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountInMismatched\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountOutLowerThanMinRequired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountOutMismatched\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionConfigNotEnabled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionEnabledOnlyForPrivateConversions\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensActive\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensPaused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DeflationaryTokenNotSupported\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxIncentive\",\"type\":\"uint256\"}],\"name\":\"IncentiveTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InputLengthMisMatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientInputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientOutputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientPoolLiquidity\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidConverterNetwork\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidMinimumAmountToConvert\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidToAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenConfigAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NonZeroIncentiveForPrivateConversion\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"calledContract\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"methodSignature\",\"type\":\"string\"}],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddressNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroValueNotAllowed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"AssetTransferredToDestination\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldBaseAsset\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newBaseAsset\",\"type\":\"address\"}],\"name\":\"BaseAssetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"oldAccess\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"newAccess\",\"type\":\"uint8\"}],\"name\":\"ConversionConfigUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionResumed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldConverterNetwork\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"converterNetwork\",\"type\":\"address\"}],\"name\":\"ConverterNetworkAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldDestinationAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"}],\"name\":\"DestinationAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldMinAmountToConvert\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newMinAmountToConvert\",\"type\":\"uint256\"}],\"name\":\"MinAmountToConvertUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldAccessControlManager\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAccessControlManager\",\"type\":\"address\"}],\"name\":\"NewAccessControlManager\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"oldPriceOracle\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle\",\"type\":\"address\"}],\"name\":\"PriceOracleUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SweepToken\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MAX_INCENTIVE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"accessControlManager\",\"outputs\":[{\"internalType\":\"contract IAccessControlManagerV8\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"baseAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"conversionConfigurations\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"conversionPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"converterNetwork\",\"outputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"destinationAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"},{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minAmountToConvert\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"priceOracle\",\"outputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"}],\"name\":\"setAccessControlManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"}],\"name\":\"setBaseAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig\",\"name\":\"conversionConfig\",\"type\":\"tuple\"}],\"name\":\"setConversionConfig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"tokenAddressesOut\",\"type\":\"address[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig[]\",\"name\":\"conversionConfigs\",\"type\":\"tuple[]\"}],\"name\":\"setConversionConfigs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"converterNetwork_\",\"type\":\"address\"}],\"name\":\"setConverterNetwork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"}],\"name\":\"setDestination\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"setMinAmountToConvert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"}],\"name\":\"setPriceOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sweepToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"updateAssetsState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Venus\",\"custom:security-contact\":\"https://github.com/VenusProtocol/protocol-reserve#discussion\",\"events\":{\"Initialized(uint8)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"}},\"kind\":\"dev\",\"methods\":{\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"balanceOf(address)\":{\"params\":{\"tokenAddress\":\"Address of the token\"},\"returns\":{\"tokenBalance\":\"Balance of the token the contract has\"}},\"constructor\":{\"custom:oz-upgrades-unsafe-allow\":\"constructor\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissaAmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissaAmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\",\"custom:event\":\"Emits ConvertedForExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\",\"custom:event\":\"Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"getAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"getUpdatedAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getUpdatedAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"initialize(address,address,address,address,uint256)\":{\"params\":{\"accessControlManager_\":\"Access control manager contract address\",\"baseAsset_\":\"Address of the base asset\",\"destinationAddress_\":\"Address at all incoming tokens will transferred to\",\"minAmountToConvert_\":\"Minimum amount to convert\",\"priceOracle_\":\"Resilient oracle address\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pauseConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensPaused thrown when conversion is already paused\",\"custom:event\":\"Emits ConversionPaused on success\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"resumeConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensActive thrown when conversion is already active\",\"custom:event\":\"Emits ConversionResumed on success\"},\"setAccessControlManager(address)\":{\"custom:access\":\"Only Governance\",\"custom:event\":\"Emits NewAccessControlManager event\",\"details\":\"Admin function to set address of AccessControlManager\",\"params\":{\"accessControlManager_\":\"The new address of the AccessControlManager\"}},\"setBaseAsset(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"baseAsset_\":\"The new address of the base asset\"}},\"setConversionConfig(address,address,(uint256,uint8))\":{\"custom:access\":\"Controlled by AccessControlManager\",\"custom:error\":\"Unauthorized error is thrown when the call is not authorized by AccessControlManagerZeroAddressNotAllowed is thrown when pool registry address is zeroNonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\",\"custom:event\":\"Emits ConversionConfigUpdated event on success\",\"params\":{\"conversionConfig\":\"ConversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressOut\":\"Address of tokenOut\"}},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"custom:error\":\"InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\",\"params\":{\"conversionConfigs\":\"Array of conversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressesOut\":\"Array of addresses of tokenOut\"}},\"setConverterNetwork(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"converterNetwork_\":\"The converterNetwork address to be set\"}},\"setDestination(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"destinationAddress_\":\"The new destination address to be set\"}},\"setMinAmountToConvert(uint256)\":{\"custom:access\":\"Only Governance\",\"params\":{\"minAmountToConvert_\":\"Min amount to convert\"}},\"setPriceOracle(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"priceOracle_\":\"Address of the new price oracle to set\"}},\"sweepToken(address,address,uint256)\":{\"custom:access\":\"Only Governance\",\"custom:error\":\"ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\",\"custom:event\":\"Emits SweepToken event on success\",\"params\":{\"amount\":\"The amount to transfer\",\"to\":\"The address to which tokens will be transferred\",\"tokenAddress\":\"The address of the ERC-20 token to sweep\"}},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner.\"},\"updateAssetsState(address,address)\":{\"details\":\"This function is called by protocolShareReservecall _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\",\"params\":{\"asset\":\"Asset address\",\"comptroller\":\"Comptroller address (pool)\"}}},\"title\":\"SingleTokenConverter\",\"version\":1},\"userdoc\":{\"errors\":{\"AmountInHigherThanMax(uint256,uint256)\":[{\"notice\":\"Thrown when amountIn is higher than amountInMax\"}],\"AmountInMismatched()\":[{\"notice\":\"Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\"}],\"AmountOutLowerThanMinRequired(uint256,uint256)\":[{\"notice\":\"Thrown when amountOut is lower than amountOutMin\"}],\"AmountOutMismatched()\":[{\"notice\":\"Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\"}],\"ConversionConfigNotEnabled()\":[{\"notice\":\"Thrown when conversion is disabled or config does not exist for given pair\"}],\"ConversionEnabledOnlyForPrivateConversions()\":[{\"notice\":\"Thrown when conversion is enabled only for private conversions\"}],\"ConversionTokensActive()\":[{\"notice\":\"Thrown when conversion is Active\"}],\"ConversionTokensPaused()\":[{\"notice\":\"Thrown when conversion is paused\"}],\"DeflationaryTokenNotSupported()\":[{\"notice\":\"Thrown when using convertForExactTokens deflationary tokens\"}],\"IncentiveTooHigh(uint256,uint256)\":[{\"notice\":\"Thrown when incentive is higher than the MAX_INCENTIVE\"}],\"InputLengthMisMatch()\":[{\"notice\":\"Thrown when there is a mismatch in the length of input arrays\"}],\"InsufficientInputAmount()\":[{\"notice\":\"Thrown when given input amount is zero\"}],\"InsufficientOutputAmount()\":[{\"notice\":\"Thrown when given output amount is zero\"}],\"InsufficientPoolLiquidity()\":[{\"notice\":\"Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\"}],\"InvalidConverterNetwork()\":[{\"notice\":\"When address of the ConverterNetwork is not set or Zero address\"}],\"InvalidMinimumAmountToConvert()\":[{\"notice\":\"Thrown when minimum amount to convert is zero\"}],\"InvalidToAddress()\":[{\"notice\":\"Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\"}],\"InvalidTokenConfigAddresses()\":[{\"notice\":\"Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\"}],\"NonZeroIncentiveForPrivateConversion()\":[{\"notice\":\"Thrown when trying to set non zero incentive for private conversion\"}],\"Unauthorized(address,address,string)\":[{\"notice\":\"Thrown when the action is prohibited by AccessControlManager\"}],\"ZeroAddressNotAllowed()\":[{\"notice\":\"Thrown if the supplied address is a zero address where it is not allowed\"}],\"ZeroValueNotAllowed()\":[{\"notice\":\"Thrown if the supplied value is 0 where it is not allowed\"}]},\"events\":{\"AssetTransferredToDestination(address,address,address,uint256)\":{\"notice\":\"Emmitted after the funds transferred to the destination address\"},\"BaseAssetUpdated(address,address)\":{\"notice\":\"Emitted when base asset is updated\"},\"ConversionConfigUpdated(address,address,uint256,uint256,uint8,uint8)\":{\"notice\":\"Emitted when config is updated for tokens pair\"},\"ConversionPaused(address)\":{\"notice\":\"Emitted when conversion is paused\"},\"ConversionResumed(address)\":{\"notice\":\"Emitted when conversion is unpaused\"},\"ConvertedExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens\"},\"ConvertedExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\"},\"ConvertedForExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens\"},\"ConvertedForExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\"},\"ConverterNetworkAddressUpdated(address,address)\":{\"notice\":\"Emitted when converterNetwork address is updated\"},\"DestinationAddressUpdated(address,address)\":{\"notice\":\"Emitted when destination address is updated\"},\"MinAmountToConvertUpdated(uint256,uint256)\":{\"notice\":\"Emitted when minimum amount to convert is updated\"},\"NewAccessControlManager(address,address)\":{\"notice\":\"Emitted when access control manager contract address is changed\"},\"PriceOracleUpdated(address,address)\":{\"notice\":\"Emitted when price oracle address is updated\"},\"SweepToken(address,address,uint256)\":{\"notice\":\"Event emitted when tokens are swept\"}},\"kind\":\"user\",\"methods\":{\"MAX_INCENTIVE()\":{\"notice\":\"Maximum incentive could be\"},\"accessControlManager()\":{\"notice\":\"Returns the address of the access control manager contract\"},\"balanceOf(address)\":{\"notice\":\"Get the balance for specific token\"},\"baseAsset()\":{\"notice\":\"Address of the base asset token\"},\"conversionConfigurations(address,address)\":{\"notice\":\"conversion configurations for the existing pairs\"},\"conversionPaused()\":{\"notice\":\"Boolean for if conversion is paused\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract, otherwise the amount is adjusted\"},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted. The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\"},\"converterNetwork()\":{\"notice\":\"Address of the converterNetwork contract\"},\"destinationAddress()\":{\"notice\":\"Address that all incoming tokens are transferred to\"},\"getAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut. This function does not account for potential token transfer fees(in case of deflationary tokens)\"},\"getAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn. This function does not account for potential token transfer fees(in case of deflationary tokens)The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\"},\"getUpdatedAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\"},\"getUpdatedAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\"},\"minAmountToConvert()\":{\"notice\":\"Min amount to convert for private conversions. Defined in USD, with 18 decimals\"},\"pauseConversion()\":{\"notice\":\"Pause conversion of tokens\"},\"priceOracle()\":{\"notice\":\"Venus price oracle contract\"},\"resumeConversion()\":{\"notice\":\"Resume conversion of tokens.\"},\"setAccessControlManager(address)\":{\"notice\":\"Sets the address of AccessControlManager\"},\"setBaseAsset(address)\":{\"notice\":\"Sets the base asset for the contract\"},\"setConversionConfig(address,address,(uint256,uint8))\":{\"notice\":\"Set the configuration for new or existing conversion pair\"},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"notice\":\"Batch sets the conversion configurations\"},\"setConverterNetwork(address)\":{\"notice\":\"Sets a converter network contract address\"},\"setDestination(address)\":{\"notice\":\"Sets a new destination address\"},\"setMinAmountToConvert(uint256)\":{\"notice\":\"Min amount to convert setter\"},\"setPriceOracle(address)\":{\"notice\":\"Sets a new price oracle\"},\"sweepToken(address,address,uint256)\":{\"notice\":\"To sweep ERC20 tokens and transfer them to user(to address)\"},\"updateAssetsState(address,address)\":{\"notice\":\"This method updated the states of this contract after getting funds from PSR after settling the amount(if any) through privateConversion between converters\"}},\"notice\":\"SingleTokenConverter used for token conversions and sends received tokens\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/TokenConverter/SingleTokenConverter.sol\":\"SingleTokenConverter\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./OwnableUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership} and {acceptOwnership}.\\n *\\n * This module is used through inheritance. It will make available all functions\\n * from parent (Ownable).\\n */\\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\\n function __Ownable2Step_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable2Step_init_unchained() internal onlyInitializing {\\n }\\n address private _pendingOwner;\\n\\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Returns the address of the pending owner.\\n */\\n function pendingOwner() public view virtual returns (address) {\\n return _pendingOwner;\\n }\\n\\n /**\\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual override onlyOwner {\\n _pendingOwner = newOwner;\\n emit OwnershipTransferStarted(owner(), newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual override {\\n delete _pendingOwner;\\n super._transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev The new owner accepts the ownership transfer.\\n */\\n function acceptOwnership() public virtual {\\n address sender = _msgSender();\\n require(pendingOwner() == sender, \\\"Ownable2Step: caller is not the new owner\\\");\\n _transferOwnership(sender);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x84efb8889801b0ac817324aff6acc691d07bbee816b671817132911d287a8c63\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n function __Ownable_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable_init_unchained() internal onlyInitializing {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby disabling any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x4075622496acc77fd6d4de4cc30a8577a744d5c75afad33fdeacf1704d6eda98\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts.\\n *\\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n * constructor.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n * are added through upgrades and that require initialization.\\n *\\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n * cannot be nested. If one is invoked in the context of another, execution will revert.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n *\\n * WARNING: setting the version to 255 will prevent any future reinitialization.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n *\\n * Emits an {Initialized} event the first time it is successfully executed.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized != type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n\\n /**\\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n */\\n function _getInitializedVersion() internal view returns (uint8) {\\n return _initialized;\\n }\\n\\n /**\\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n */\\n function _isInitializing() internal view returns (bool) {\\n return _initializing;\\n }\\n}\\n\",\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state.\\n */\\n function __Pausable_init() internal onlyInitializing {\\n __Pausable_init_unchained();\\n }\\n\\n function __Pausable_init_unchained() internal onlyInitializing {\\n _paused = false;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused() {\\n _requireNotPaused();\\n _;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier whenPaused() {\\n _requirePaused();\\n _;\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused() public view virtual returns (bool) {\\n return _paused;\\n }\\n\\n /**\\n * @dev Throws if the contract is paused.\\n */\\n function _requireNotPaused() internal view virtual {\\n require(!paused(), \\\"Pausable: paused\\\");\\n }\\n\\n /**\\n * @dev Throws if the contract is not paused.\\n */\\n function _requirePaused() internal view virtual {\\n require(paused(), \\\"Pausable: not paused\\\");\\n }\\n\\n /**\\n * @dev Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(_msgSender());\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n function __ReentrancyGuard_init() internal onlyInitializing {\\n __ReentrancyGuard_init_unchained();\\n }\\n\\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == _ENTERED;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xb82ef33f43b6b96109687d91b39c94573fdccaaa423fe28e8ba0977b31c023e0\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20PermitUpgradeable {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xd60f939a3ca0199014d079b4dd66aa757954334947d81eb5c1d35d7a83061ab3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\nimport \\\"../extensions/IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20Upgradeable {\\n using AddressUpgradeable for address;\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\\n * Revert on invalid signature.\\n */\\n function safePermit(\\n IERC20PermitUpgradeable token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return\\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));\\n }\\n}\\n\",\"keccak256\":\"0x23b997be73d3dd46885262704f0f8cfc7273fdadfe303d37969a9561373972b5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n *\\n * Furthermore, `isContract` will also return true if the target contract within\\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n * which only has an effect at the end of a transaction.\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal onlyInitializing {\\n }\\n\\n function __Context_init_unchained() internal onlyInitializing {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl {\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\"},\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\\\";\\n\\nimport \\\"./IAccessControlManagerV8.sol\\\";\\n\\n/**\\n * @title AccessControlledV8\\n * @author Venus\\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.8.13)\\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\\n */\\nabstract contract AccessControlledV8 is Initializable, Ownable2StepUpgradeable {\\n /// @notice Access control manager contract\\n IAccessControlManagerV8 private _accessControlManager;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n\\n /// @notice Emitted when access control manager contract address is changed\\n event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\\n\\n /// @notice Thrown when the action is prohibited by AccessControlManager\\n error Unauthorized(address sender, address calledContract, string methodSignature);\\n\\n function __AccessControlled_init(address accessControlManager_) internal onlyInitializing {\\n __Ownable2Step_init();\\n __AccessControlled_init_unchained(accessControlManager_);\\n }\\n\\n function __AccessControlled_init_unchained(address accessControlManager_) internal onlyInitializing {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Sets the address of AccessControlManager\\n * @dev Admin function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n * @custom:event Emits NewAccessControlManager event\\n * @custom:access Only Governance\\n */\\n function setAccessControlManager(address accessControlManager_) external onlyOwner {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Returns the address of the access control manager contract\\n */\\n function accessControlManager() external view returns (IAccessControlManagerV8) {\\n return _accessControlManager;\\n }\\n\\n /**\\n * @dev Internal function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n */\\n function _setAccessControlManager(address accessControlManager_) internal {\\n require(address(accessControlManager_) != address(0), \\\"invalid acess control manager address\\\");\\n address oldAccessControlManager = address(_accessControlManager);\\n _accessControlManager = IAccessControlManagerV8(accessControlManager_);\\n emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\\n }\\n\\n /**\\n * @notice Reverts if the call is not allowed by AccessControlManager\\n * @param signature Method signature\\n */\\n function _checkAccessAllowed(string memory signature) internal view {\\n bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\\n\\n if (!isAllowedToCall) {\\n revert Unauthorized(msg.sender, address(this), signature);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0dcf283925f4dddc23ca0ee71d2cb96a9dd6e4cf08061b69fde1697ea39dc514\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/access/IAccessControl.sol\\\";\\n\\n/**\\n * @title IAccessControlManagerV8\\n * @author Venus\\n * @notice Interface implemented by the `AccessControlManagerV8` contract.\\n */\\ninterface IAccessControlManagerV8 is IAccessControl {\\n function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\\n\\n function revokeCallPermission(\\n address contractAddress,\\n string calldata functionSig,\\n address accountToRevoke\\n ) external;\\n\\n function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\\n\\n function hasPermission(\\n address account,\\n address contractAddress,\\n string calldata functionSig\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xaa29b098440d0b3a131c5ecdf25ce548790c1b5ac7bf9b5c0264b6af6f7a1e0b\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/ResilientOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\n// SPDX-FileCopyrightText: 2022 Venus\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\nimport \\\"./interfaces/VBep20Interface.sol\\\";\\nimport \\\"./interfaces/OracleInterface.sol\\\";\\nimport \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\n\\n/**\\n * @title ResilientOracle\\n * @author Venus\\n * @notice The Resilient Oracle is the main contract that the protocol uses to fetch prices of assets.\\n *\\n * DeFi protocols are vulnerable to price oracle failures including oracle manipulation and incorrectly\\n * reported prices. If only one oracle is used, this creates a single point of failure and opens a vector\\n * for attacking the protocol.\\n *\\n * The Resilient Oracle uses multiple sources and fallback mechanisms to provide accurate prices and protect\\n * the protocol from oracle attacks. Currently it includes integrations with Chainlink, Pyth, Binance Oracle\\n * and TWAP (Time-Weighted Average Price) oracles. TWAP uses PancakeSwap as the on-chain price source.\\n *\\n * For every market (vToken) we configure the main, pivot and fallback oracles. The oracles are configured per\\n * vToken's underlying asset address. The main oracle oracle is the most trustworthy price source, the pivot\\n * oracle is used as a loose sanity checker and the fallback oracle is used as a backup price source.\\n *\\n * To validate prices returned from two oracles, we use an upper and lower bound ratio that is set for every\\n * market. The upper bound ratio represents the deviation between reported price (the price that\\u2019s being\\n * validated) and the anchor price (the price we are validating against) above which the reported price will\\n * be invalidated. The lower bound ratio presents the deviation between reported price and anchor price below\\n * which the reported price will be invalidated. So for oracle price to be considered valid the below statement\\n * should be true:\\n\\n```\\nanchorRatio = anchorPrice/reporterPrice\\nisValid = anchorRatio <= upperBoundAnchorRatio && anchorRatio >= lowerBoundAnchorRatio\\n```\\n\\n * In most cases, Chainlink is used as the main oracle, TWAP or Pyth oracles are used as the pivot oracle depending\\n * on which supports the given market and Binance oracle is used as the fallback oracle. For some markets we may\\n * use Pyth or TWAP as the main oracle if the token price is not supported by Chainlink or Binance oracles.\\n *\\n * For a fetched price to be valid it must be positive and not stagnant. If the price is invalid then we consider the\\n * oracle to be stagnant and treat it like it's disabled.\\n */\\ncontract ResilientOracle is PausableUpgradeable, AccessControlledV8, ResilientOracleInterface {\\n /**\\n * @dev Oracle roles:\\n * **main**: The most trustworthy price source\\n * **pivot**: Price oracle used as a loose sanity checker\\n * **fallback**: The backup source when main oracle price is invalidated\\n */\\n enum OracleRole {\\n MAIN,\\n PIVOT,\\n FALLBACK\\n }\\n\\n struct TokenConfig {\\n /// @notice asset address\\n address asset;\\n /// @notice `oracles` stores the oracles based on their role in the following order:\\n /// [main, pivot, fallback],\\n /// It can be indexed with the corresponding enum OracleRole value\\n address[3] oracles;\\n /// @notice `enableFlagsForOracles` stores the enabled state\\n /// for each oracle in the same order as `oracles`\\n bool[3] enableFlagsForOracles;\\n }\\n\\n uint256 public constant INVALID_PRICE = 0;\\n\\n /// @notice Native market address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable nativeMarket;\\n\\n /// @notice VAI address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable vai;\\n\\n /// @notice Set this as asset address for Native token on each chain.This is the underlying for vBNB (on bsc)\\n /// and can serve as any underlying asset of a market that supports native tokens\\n address public constant NATIVE_TOKEN_ADDR = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\\n\\n /// @notice Bound validator contract address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n BoundValidatorInterface public immutable boundValidator;\\n\\n mapping(address => TokenConfig) private tokenConfigs;\\n\\n event TokenConfigAdded(\\n address indexed asset,\\n address indexed mainOracle,\\n address indexed pivotOracle,\\n address fallbackOracle\\n );\\n\\n /// Event emitted when an oracle is set\\n event OracleSet(address indexed asset, address indexed oracle, uint256 indexed role);\\n\\n /// Event emitted when an oracle is enabled or disabled\\n event OracleEnabled(address indexed asset, uint256 indexed role, bool indexed enable);\\n\\n /**\\n * @notice Checks whether an address is null or not\\n */\\n modifier notNullAddress(address someone) {\\n if (someone == address(0)) revert(\\\"can't be zero address\\\");\\n _;\\n }\\n\\n /**\\n * @notice Checks whether token config exists by checking whether asset is null address\\n * @dev address can't be null, so it's suitable to be used to check the validity of the config\\n * @param asset asset address\\n */\\n modifier checkTokenConfigExistence(address asset) {\\n if (tokenConfigs[asset].asset == address(0)) revert(\\\"token config must exist\\\");\\n _;\\n }\\n\\n /// @notice Constructor for the implementation contract. Sets immutable variables.\\n /// @dev nativeMarketAddress can be address(0) if on the chain we do not support native market\\n /// (e.g vETH on ethereum would not be supported, only vWETH)\\n /// @param nativeMarketAddress The address of a native market (for bsc it would be vBNB address)\\n /// @param vaiAddress The address of the VAI token (if there is VAI on the deployed chain).\\n /// Set to address(0) of VAI is not existent.\\n /// @param _boundValidator Address of the bound validator contract\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor(\\n address nativeMarketAddress,\\n address vaiAddress,\\n BoundValidatorInterface _boundValidator\\n ) notNullAddress(address(_boundValidator)) {\\n nativeMarket = nativeMarketAddress;\\n vai = vaiAddress;\\n boundValidator = _boundValidator;\\n\\n _disableInitializers();\\n }\\n\\n /**\\n * @notice Initializes the contract admin and sets the BoundValidator contract address\\n * @param accessControlManager_ Address of the access control manager contract\\n */\\n function initialize(address accessControlManager_) external initializer {\\n __AccessControlled_init(accessControlManager_);\\n __Pausable_init();\\n }\\n\\n /**\\n * @notice Pauses oracle\\n * @custom:access Only Governance\\n */\\n function pause() external {\\n _checkAccessAllowed(\\\"pause()\\\");\\n _pause();\\n }\\n\\n /**\\n * @notice Unpauses oracle\\n * @custom:access Only Governance\\n */\\n function unpause() external {\\n _checkAccessAllowed(\\\"unpause()\\\");\\n _unpause();\\n }\\n\\n /**\\n * @notice Batch sets token configs\\n * @param tokenConfigs_ Token config array\\n * @custom:access Only Governance\\n * @custom:error Throws a length error if the length of the token configs array is 0\\n */\\n function setTokenConfigs(TokenConfig[] memory tokenConfigs_) external {\\n if (tokenConfigs_.length == 0) revert(\\\"length can't be 0\\\");\\n uint256 numTokenConfigs = tokenConfigs_.length;\\n for (uint256 i; i < numTokenConfigs; ) {\\n setTokenConfig(tokenConfigs_[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /**\\n * @notice Sets oracle for a given asset and role.\\n * @dev Supplied asset **must** exist and main oracle may not be null\\n * @param asset Asset address\\n * @param oracle Oracle address\\n * @param role Oracle role\\n * @custom:access Only Governance\\n * @custom:error Null address error if main-role oracle address is null\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n * @custom:event Emits OracleSet event with asset address, oracle address and role of the oracle for the asset\\n */\\n function setOracle(\\n address asset,\\n address oracle,\\n OracleRole role\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"setOracle(address,address,uint8)\\\");\\n if (oracle == address(0) && role == OracleRole.MAIN) revert(\\\"can't set zero address to main oracle\\\");\\n tokenConfigs[asset].oracles[uint256(role)] = oracle;\\n emit OracleSet(asset, oracle, uint256(role));\\n }\\n\\n /**\\n * @notice Enables/ disables oracle for the input asset. Token config for the input asset **must** exist\\n * @dev Configuration for the asset **must** already exist and the asset cannot be 0 address\\n * @param asset Asset address\\n * @param role Oracle role\\n * @param enable Enabled boolean of the oracle\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n */\\n function enableOracle(\\n address asset,\\n OracleRole role,\\n bool enable\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"enableOracle(address,uint8,bool)\\\");\\n tokenConfigs[asset].enableFlagsForOracles[uint256(role)] = enable;\\n emit OracleEnabled(asset, uint256(role), enable);\\n }\\n\\n /**\\n * @notice Updates the TWAP pivot oracle price.\\n * @dev This function should always be called before calling getUnderlyingPrice\\n * @param vToken vToken address\\n */\\n function updatePrice(address vToken) external override {\\n address asset = _getUnderlyingAsset(vToken);\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @notice Updates the pivot oracle price. Currently using TWAP\\n * @dev This function should always be called before calling getPrice\\n * @param asset asset address\\n */\\n function updateAssetPrice(address asset) external {\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @dev Gets token config by asset address\\n * @param asset asset address\\n * @return tokenConfig Config for the asset\\n */\\n function getTokenConfig(address asset) external view returns (TokenConfig memory) {\\n return tokenConfigs[asset];\\n }\\n\\n /**\\n * @notice Gets price of the underlying asset for a given vToken. Validation flow:\\n * - Check if the oracle is paused globally\\n * - Validate price from main oracle against pivot oracle\\n * - Validate price from fallback oracle against pivot oracle if the first validation failed\\n * - Validate price from main oracle against fallback oracle if the second validation failed\\n * In the case that the pivot oracle is not available but main price is available and validation is successful,\\n * main oracle price is returned.\\n * @param vToken vToken address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getUnderlyingPrice(address vToken) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n\\n address asset = _getUnderlyingAsset(vToken);\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Gets price of the asset\\n * @param asset asset address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getPrice(address asset) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Sets/resets single token configs.\\n * @dev main oracle **must not** be a null address\\n * @param tokenConfig Token config struct\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress is thrown if asset address is null\\n * @custom:error NotNullAddress is thrown if main-role oracle address for asset is null\\n * @custom:event Emits TokenConfigAdded event when the asset config is set successfully by the authorized account\\n */\\n function setTokenConfig(\\n TokenConfig memory tokenConfig\\n ) public notNullAddress(tokenConfig.asset) notNullAddress(tokenConfig.oracles[uint256(OracleRole.MAIN)]) {\\n _checkAccessAllowed(\\\"setTokenConfig(TokenConfig)\\\");\\n\\n tokenConfigs[tokenConfig.asset] = tokenConfig;\\n emit TokenConfigAdded(\\n tokenConfig.asset,\\n tokenConfig.oracles[uint256(OracleRole.MAIN)],\\n tokenConfig.oracles[uint256(OracleRole.PIVOT)],\\n tokenConfig.oracles[uint256(OracleRole.FALLBACK)]\\n );\\n }\\n\\n /**\\n * @notice Gets oracle and enabled status by asset address\\n * @param asset asset address\\n * @param role Oracle role\\n * @return oracle Oracle address based on role\\n * @return enabled Enabled flag of the oracle based on token config\\n */\\n function getOracle(address asset, OracleRole role) public view returns (address oracle, bool enabled) {\\n oracle = tokenConfigs[asset].oracles[uint256(role)];\\n enabled = tokenConfigs[asset].enableFlagsForOracles[uint256(role)];\\n }\\n\\n function _getPrice(address asset) internal view returns (uint256) {\\n uint256 pivotPrice = INVALID_PRICE;\\n\\n // Get pivot oracle price, Invalid price if not available or error\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracleEnabled && pivotOracle != address(0)) {\\n try OracleInterface(pivotOracle).getPrice(asset) returns (uint256 pricePivot) {\\n pivotPrice = pricePivot;\\n } catch {}\\n }\\n\\n // Compare main price and pivot price, return main price and if validation was successful\\n // note: In case pivot oracle is not available but main price is available and\\n // validation is successful, the main oracle price is returned.\\n (uint256 mainPrice, bool validatedPivotMain) = _getMainOraclePrice(\\n asset,\\n pivotPrice,\\n pivotOracleEnabled && pivotOracle != address(0)\\n );\\n if (mainPrice != INVALID_PRICE && validatedPivotMain) return mainPrice;\\n\\n // Compare fallback and pivot if main oracle comparision fails with pivot\\n // Return fallback price when fallback price is validated successfully with pivot oracle\\n (uint256 fallbackPrice, bool validatedPivotFallback) = _getFallbackOraclePrice(asset, pivotPrice);\\n if (fallbackPrice != INVALID_PRICE && validatedPivotFallback) return fallbackPrice;\\n\\n // Lastly compare main price and fallback price\\n if (\\n mainPrice != INVALID_PRICE &&\\n fallbackPrice != INVALID_PRICE &&\\n boundValidator.validatePriceWithAnchorPrice(asset, mainPrice, fallbackPrice)\\n ) {\\n return mainPrice;\\n }\\n\\n revert(\\\"invalid resilient oracle price\\\");\\n }\\n\\n /**\\n * @notice Gets a price for the provided asset\\n * @dev This function won't revert when price is 0, because the fallback oracle may still be\\n * able to fetch a correct price\\n * @param asset asset address\\n * @param pivotPrice Pivot oracle price\\n * @param pivotEnabled If pivot oracle is not empty and enabled\\n * @return price USD price in scaled decimals\\n * e.g. asset decimals is 8 then price is returned as 10**18 * 10**(18-8) = 10**28 decimals\\n * @return pivotValidated Boolean representing if the validation of main oracle price\\n * and pivot oracle price were successful\\n * @custom:error Invalid price error is thrown if main oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if main oracle is not enabled or main oracle\\n * address is null\\n */\\n function _getMainOraclePrice(\\n address asset,\\n uint256 pivotPrice,\\n bool pivotEnabled\\n ) internal view returns (uint256, bool) {\\n (address mainOracle, bool mainOracleEnabled) = getOracle(asset, OracleRole.MAIN);\\n if (mainOracleEnabled && mainOracle != address(0)) {\\n try OracleInterface(mainOracle).getPrice(asset) returns (uint256 mainOraclePrice) {\\n if (!pivotEnabled) {\\n return (mainOraclePrice, true);\\n }\\n if (pivotPrice == INVALID_PRICE) {\\n return (mainOraclePrice, false);\\n }\\n return (\\n mainOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, mainOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function won't revert when the price is 0 because getPrice checks if price is > 0\\n * @param asset asset address\\n * @return price USD price in 18 decimals\\n * @return pivotValidated Boolean representing if the validation of fallback oracle price\\n * and pivot oracle price were successfully\\n * @custom:error Invalid price error is thrown if fallback oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if fallback oracle is not enabled or fallback oracle\\n * address is null\\n */\\n function _getFallbackOraclePrice(address asset, uint256 pivotPrice) private view returns (uint256, bool) {\\n (address fallbackOracle, bool fallbackEnabled) = getOracle(asset, OracleRole.FALLBACK);\\n if (fallbackEnabled && fallbackOracle != address(0)) {\\n try OracleInterface(fallbackOracle).getPrice(asset) returns (uint256 fallbackOraclePrice) {\\n if (pivotPrice == INVALID_PRICE) {\\n return (fallbackOraclePrice, false);\\n }\\n return (\\n fallbackOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, fallbackOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function returns the underlying asset of a vToken\\n * @param vToken vToken address\\n * @return asset underlying asset address\\n */\\n function _getUnderlyingAsset(address vToken) private view notNullAddress(vToken) returns (address asset) {\\n if (vToken == nativeMarket) {\\n asset = NATIVE_TOKEN_ADDR;\\n } else if (vToken == vai) {\\n asset = vai;\\n } else {\\n asset = VBep20Interface(vToken).underlying();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xdaaa90daa8ca5bda477729aaa5d5ff3e5305635baec1799a368d564ae2a13c4c\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\ninterface OracleInterface {\\n function getPrice(address asset) external view returns (uint256);\\n}\\n\\ninterface ResilientOracleInterface is OracleInterface {\\n function updatePrice(address vToken) external;\\n\\n function updateAssetPrice(address asset) external;\\n\\n function getUnderlyingPrice(address vToken) external view returns (uint256);\\n}\\n\\ninterface TwapInterface is OracleInterface {\\n function updateTwap(address asset) external returns (uint256);\\n}\\n\\ninterface BoundValidatorInterface {\\n function validatePriceWithAnchorPrice(\\n address asset,\\n uint256 reporterPrice,\\n uint256 anchorPrice\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x2432799b0d824fc701beb4c30146e912b9aeecf77b5c1635dde6c5fbe6bfc3a7\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/VBep20Interface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\ninterface VBep20Interface is IERC20Metadata {\\n /**\\n * @notice Underlying asset for this VToken\\n */\\n function underlying() external view returns (address);\\n}\\n\",\"keccak256\":\"0x6e71c3df86501df5c0e4bace1333c0c91f9f9cced252a54fb99eeda219b789d5\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/constants.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\n/// @dev Base unit for computations, usually used in scaling (multiplications, divisions)\\nuint256 constant EXP_SCALE = 1e18;\\n\\n/// @dev A unit (literal one) in EXP_SCALE, usually used in additions/subtractions\\nuint256 constant MANTISSA_ONE = EXP_SCALE;\\n\\n/// @dev The approximate number of seconds per year\\nuint256 constant SECONDS_PER_YEAR = 31_536_000;\\n\",\"keccak256\":\"0x14de93ead464da249af31bea0e3bcfb62ec693bea3475fb4d90f055ac81dc5eb\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/validators.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\n/// @notice Thrown if the supplied address is a zero address where it is not allowed\\nerror ZeroAddressNotAllowed();\\n\\n/// @notice Thrown if the supplied value is 0 where it is not allowed\\nerror ZeroValueNotAllowed();\\n\\n/// @notice Checks if the provided address is nonzero, reverts otherwise\\n/// @param address_ Address to check\\n/// @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address\\nfunction ensureNonzeroAddress(address address_) pure {\\n if (address_ == address(0)) {\\n revert ZeroAddressNotAllowed();\\n }\\n}\\n\\n/// @notice Checks if the provided value is nonzero, reverts otherwise\\n/// @param value_ Value to check\\n/// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\nfunction ensureNonzeroValue(uint256 value_) pure {\\n if (value_ == 0) {\\n revert ZeroValueNotAllowed();\\n }\\n}\\n\",\"keccak256\":\"0xdb88e14d50dd21889ca3329d755673d022c47e8da005b6a545c7f69c2c4b7b86\",\"license\":\"BSD-3-Clause\"},\"contracts/Interfaces/IConverterNetwork.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { IAbstractTokenConverter } from \\\"../TokenConverter/IAbstractTokenConverter.sol\\\";\\n\\n/**\\n * @title IConverterNetwork\\n * @author Venus\\n * @notice Interface implemented by `ConverterNetwork`.\\n */\\ninterface IConverterNetwork {\\n /// @notice Adds new converter to the array\\n /// @param _tokenConverter Address of the token converter\\n function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Removes converter from the array\\n /// @param _tokenConverter Address of the token converter\\n function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice This function returns the array containing all the converters addresses\\n /// @return Array containing all the converters addresses\\n function getAllConverters() external view returns (IAbstractTokenConverter[] memory);\\n\\n /// @notice This function checks for given address is converter or not\\n /// @param _tokenConverter Address of the token converter\\n /// @return boolean true if given address is converter otherwise false\\n function isTokenConverter(address _tokenConverter) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xd9a747f176d9b9de220331b87ed711cc2bd594a118b538a35f3c47060bff7a8b\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/AbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { ReentrancyGuardUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { AccessControlledV8 } from \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress, ensureNonzeroValue } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\nimport { MANTISSA_ONE, EXP_SCALE } from \\\"@venusprotocol/solidity-utilities/contracts/constants.sol\\\";\\n\\nimport { IAbstractTokenConverter } from \\\"./IAbstractTokenConverter.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @title AbstractTokenConverter\\n/// @author Venus\\n/// @notice Abstract contract will be extended by SingleTokenConverter and RiskFundConverter\\n/*\\n * This contract specifies four functions for converting tokens, each applicable under following circumstances:\\n *\\n * Case I: TokenIn -> deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions supporting fees can only be utilized to convert tokens which are:\\n * a. convertExactTokensSupportingFeeOnTransferTokens\\n * b. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case II: TokenIn -> deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions supporting fee can only be utilized to convert tokens which are:\\n * similar to Case I.\\n *\\n * Case III: TokenIn -> non-deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * a. convertExactTokens\\n * b. convertForExactTokens\\n * c. convertExactTokensSupportingFeeOnTransferTokens\\n * d. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case IV: TokenIn -> non-deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * similar to Case III.\\n *\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n * Example 1:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInAmount - 100\\n * tokenOutMinAmount - minimum amount desired by the user(let's say 70)\\n * Here user can use `convertExactTokens` or `convertExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertExactTokens` is used).\\n * Now first tokenInAddress tokens will be transferred from the user to the contract, on the basis of amount\\n * received(as tokenInAddress can be deflationary token) tokenAmountOut will be calculated and will be transferred\\n * to the user and if amount sent is less than tokenOutMinAmount, tx will revert. If amount sent is satisfied(let's say\\n * 80 or even 70) then at last the actual amount received and the amount that was supposed to be received by the contract will\\n * be compared, if they differ then the whole tx will revert as user was supposed to use `convertExactTokensSupportingFeeOnTransferTokens`\\n * function for tokenIn as deflationary token.\\n *\\n * Example 2:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInMaxAmount - maximum amount user is willing to provide(let's say 100)\\n * tokenOutAmount - 70\\n * Here user can use `convertForExactTokens` or `convertForExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertForExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertForExactTokens` is used),\\n * which on the basis of tokenOutAmount provided will calculate tokenInAmount based on the tokens prices and will transfer\\n * tokens from the user to the contract, now the actual amount received(as tokenInAddress can be deflationary token) will be\\n * compared with tokenInMaxAmount if it is greater, tx will revert. If In amount is satisfied(let's say 90 or even 100) then\\n * new tokenOutAmount will be calculated, and tokenOutAddress tokens will be transferred to the user, but at last the\\n * old tokenOutAmount and new tokenOutAmount will be compared and if they differ whole tx will revert, because user was\\n * supposed to use `convertForExactTokensSupportingFeeOnTransferTokens` function for tokenIn as deflationary token.\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n *\\n * This contract also supports private conversion between the converters:\\n * Private conversions:\\n * Private conversions is designed in order to convert the maximum amount of tokens received from PSR(to any converter) between\\n * existing converters to save incentive and lower the dependency of users for conversion. So Private Conversion will be executed\\n * by converters on it's own whenever funds are received from PSR. No incentive will be offered during private conversion.\\n *\\n * It will execute on updateAssetsState() function call in Converter Contracts. After this function call, converter will first\\n * check for the amount received. If base asset is received then it will be directly sent to the destination address and no private\\n * conversion will happen otherwise converter will interact with ConverterNetwork contract to find other valid converters who are providing the conversion for:\\n *\\n * tokenAddressIn: As asset received by that converter on updateAssetsState() function call.\\n * tokenAddressOut: As base asset of that converter.\\n *\\n * ConverterNetwork:\\n * This contract will contain all the converters, and will provide valid converters which can perform the execution according to tokenAddressIn\\n * and tokenAddressOut provided.\\n *\\n * findTokenConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for users).\\n *\\n * findTokenConvertersForConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for converters).\\n */\\n\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\nabstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenConverter, ReentrancyGuardUpgradeable {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Maximum incentive could be\\n uint256 public constant MAX_INCENTIVE = 0.5e18;\\n\\n /// @notice Min amount to convert for private conversions. Defined in USD, with 18 decimals\\n uint256 public minAmountToConvert;\\n\\n /// @notice Venus price oracle contract\\n ResilientOracle public priceOracle;\\n\\n /// @notice conversion configurations for the existing pairs\\n /// @dev tokenAddressIn => tokenAddressOut => ConversionConfig\\n mapping(address => mapping(address => ConversionConfig)) public conversionConfigurations;\\n\\n /// @notice Address that all incoming tokens are transferred to\\n address public destinationAddress;\\n\\n /// @notice Boolean for if conversion is paused\\n bool public conversionPaused;\\n\\n /// @notice Address of the converterNetwork contract\\n IConverterNetwork public converterNetwork;\\n\\n /// @dev This empty reserved space is put in place to allow future versions to add new\\n /// variables without shifting down storage in the inheritance chain.\\n /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n uint256[45] private __gap;\\n\\n /// @notice Emitted when config is updated for tokens pair\\n event ConversionConfigUpdated(\\n address indexed tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 oldIncentive,\\n uint256 newIncentive,\\n ConversionAccessibility oldAccess,\\n ConversionAccessibility newAccess\\n );\\n /// @notice Emitted when price oracle address is updated\\n event PriceOracleUpdated(ResilientOracle indexed oldPriceOracle, ResilientOracle indexed priceOracle);\\n\\n /// @notice Emitted when destination address is updated\\n event DestinationAddressUpdated(address indexed oldDestinationAddress, address indexed destinationAddress);\\n\\n /// @notice Emitted when converterNetwork address is updated\\n event ConverterNetworkAddressUpdated(address indexed oldConverterNetwork, address indexed converterNetwork);\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens\\n event ConvertedExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens\\n event ConvertedForExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\\n event ConvertedExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\\n event ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when conversion is paused\\n event ConversionPaused(address indexed sender);\\n\\n /// @notice Emitted when conversion is unpaused\\n event ConversionResumed(address indexed sender);\\n\\n /// @notice Event emitted when tokens are swept\\n event SweepToken(address indexed token, address indexed to, uint256 amount);\\n\\n /// @notice Emitted when minimum amount to convert is updated\\n event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);\\n\\n /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\\n error AmountOutMismatched();\\n\\n /// @notice Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\\n error AmountInMismatched();\\n\\n /// @notice Thrown when given input amount is zero\\n error InsufficientInputAmount();\\n\\n /// @notice Thrown when given output amount is zero\\n error InsufficientOutputAmount();\\n\\n /// @notice Thrown when conversion is disabled or config does not exist for given pair\\n error ConversionConfigNotEnabled();\\n\\n /// @notice Thrown when conversion is enabled only for private conversions\\n error ConversionEnabledOnlyForPrivateConversions();\\n\\n /// @notice Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n error InvalidToAddress();\\n\\n /// @notice Thrown when incentive is higher than the MAX_INCENTIVE\\n error IncentiveTooHigh(uint256 incentive, uint256 maxIncentive);\\n\\n /// @notice Thrown when amountOut is lower than amountOutMin\\n error AmountOutLowerThanMinRequired(uint256 amountOutMantissa, uint256 amountOutMinMantissa);\\n\\n /// @notice Thrown when amountIn is higher than amountInMax\\n error AmountInHigherThanMax(uint256 amountInMantissa, uint256 amountInMaxMantissa);\\n\\n /// @notice Thrown when conversion is paused\\n error ConversionTokensPaused();\\n\\n /// @notice Thrown when conversion is Active\\n error ConversionTokensActive();\\n\\n /// @notice Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\\n error InvalidTokenConfigAddresses();\\n\\n /// @notice Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\\n error InsufficientPoolLiquidity();\\n\\n /// @notice When address of the ConverterNetwork is not set or Zero address\\n error InvalidConverterNetwork();\\n\\n /// @notice Thrown when trying to set non zero incentive for private conversion\\n error NonZeroIncentiveForPrivateConversion();\\n\\n /// @notice Thrown when using convertForExactTokens deflationary tokens\\n error DeflationaryTokenNotSupported();\\n\\n /// @notice Thrown when minimum amount to convert is zero\\n error InvalidMinimumAmountToConvert();\\n\\n /// @notice Thrown when there is a mismatch in the length of input arrays\\n error InputLengthMisMatch();\\n\\n /**\\n * @notice Modifier to ensure valid conversion parameters for a token conversion\\n * and check if conversion is paused or not\\n * @param to The recipient address for the converted tokens\\n * @param tokenAddressIn The input token address for the conversion\\n * @param tokenAddressOut The output token address for the conversion\\n */\\n modifier validConversionParameters(\\n address to,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) {\\n _checkConversionPaused();\\n ensureNonzeroAddress(to);\\n if (to == tokenAddressIn || to == tokenAddressOut) {\\n revert InvalidToAddress();\\n }\\n _;\\n }\\n\\n /// @notice Pause conversion of tokens\\n /// @custom:event Emits ConversionPaused on success\\n /// @custom:error ConversionTokensPaused thrown when conversion is already paused\\n /// @custom:access Restricted by ACM\\n function pauseConversion() external {\\n _checkAccessAllowed(\\\"pauseConversion()\\\");\\n _checkConversionPaused();\\n conversionPaused = true;\\n emit ConversionPaused(msg.sender);\\n }\\n\\n /// @notice Resume conversion of tokens.\\n /// @custom:event Emits ConversionResumed on success\\n /// @custom:error ConversionTokensActive thrown when conversion is already active\\n /// @custom:access Restricted by ACM\\n function resumeConversion() external {\\n _checkAccessAllowed(\\\"resumeConversion()\\\");\\n if (!conversionPaused) {\\n revert ConversionTokensActive();\\n }\\n\\n conversionPaused = false;\\n emit ConversionResumed(msg.sender);\\n }\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:access Only Governance\\n function setPriceOracle(ResilientOracle priceOracle_) external onlyOwner {\\n _setPriceOracle(priceOracle_);\\n }\\n\\n /// @notice Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:access Only Governance\\n function setDestination(address destinationAddress_) external onlyOwner {\\n _setDestination(destinationAddress_);\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:access Only Governance\\n function setConverterNetwork(IConverterNetwork converterNetwork_) external onlyOwner {\\n _setConverterNetwork(converterNetwork_);\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:access Only Governance\\n function setMinAmountToConvert(uint256 minAmountToConvert_) external {\\n _checkAccessAllowed(\\\"setMinAmountToConvert(uint256)\\\");\\n _setMinAmountToConvert(minAmountToConvert_);\\n }\\n\\n /// @notice Batch sets the conversion configurations\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressesOut Array of addresses of tokenOut\\n /// @param conversionConfigs Array of conversionConfig config details to update\\n /// @custom:error InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\\n function setConversionConfigs(\\n address tokenAddressIn,\\n address[] calldata tokenAddressesOut,\\n ConversionConfig[] calldata conversionConfigs\\n ) external {\\n uint256 tokenOutArrayLength = tokenAddressesOut.length;\\n if (tokenOutArrayLength != conversionConfigs.length) revert InputLengthMisMatch();\\n\\n for (uint256 i; i < tokenOutArrayLength; ) {\\n setConversionConfig(tokenAddressIn, tokenAddressesOut[i], conversionConfigs[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n /// @custom:error AmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert AmountInMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract,\\n /// otherwise the amount is adjusted\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n /// @custom:error AmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountOut != amountOutMantissa) {\\n revert AmountOutMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of\\n /// tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted.\\n /// The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokensSupportingFeeOnTransferTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice To sweep ERC20 tokens and transfer them to user(to address)\\n /// @param tokenAddress The address of the ERC-20 token to sweep\\n /// @param to The address to which tokens will be transferred\\n /// @param amount The amount to transfer\\n /// @custom:event Emits SweepToken event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\\n /// @custom:access Only Governance\\n function sweepToken(\\n address tokenAddress,\\n address to,\\n uint256 amount\\n ) external onlyOwner nonReentrant {\\n ensureNonzeroAddress(tokenAddress);\\n ensureNonzeroAddress(to);\\n ensureNonzeroValue(amount);\\n\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n preSweepToken(tokenAddress, amount);\\n token.safeTransfer(to, amount);\\n\\n emit SweepToken(tokenAddress, to, amount);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @notice The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n amountConvertedMantissa = amountInMantissa;\\n uint256 tokenInToOutConversion;\\n (amountOutMantissa, tokenInToOutConversion) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountConvertedMantissa = _divRoundingUp(maxTokenOutReserve * EXP_SCALE, tokenInToOutConversion);\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n\\n amountConvertedMantissa = amountOutMantissa;\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountOutMantissa, ) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountInMantissa;\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountOutMantissa;\\n }\\n\\n /// @notice This method updated the states of this contract after getting funds from PSR\\n /// after settling the amount(if any) through privateConversion between converters\\n /// @dev This function is called by protocolShareReserve\\n /// @dev call _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then\\n /// it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n function updateAssetsState(address comptroller, address asset) public nonReentrant {\\n uint256 balanceDiff = _updateAssetsState(comptroller, asset);\\n if (balanceDiff > 0) {\\n _privateConversion(comptroller, asset, balanceDiff);\\n }\\n }\\n\\n /// @notice Set the configuration for new or existing conversion pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n /// @custom:event Emits ConversionConfigUpdated event on success\\n /// @custom:error Unauthorized error is thrown when the call is not authorized by AccessControlManager\\n /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero\\n /// @custom:error NonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\\n /// @custom:access Controlled by AccessControlManager\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) public {\\n _checkAccessAllowed(\\\"setConversionConfig(address,address,ConversionConfig)\\\");\\n ensureNonzeroAddress(tokenAddressIn);\\n ensureNonzeroAddress(tokenAddressOut);\\n\\n if (conversionConfig.incentive > MAX_INCENTIVE) {\\n revert IncentiveTooHigh(conversionConfig.incentive, MAX_INCENTIVE);\\n }\\n\\n if (\\n (tokenAddressIn == tokenAddressOut) ||\\n (tokenAddressIn != _getDestinationBaseAsset()) ||\\n conversionConfigurations[tokenAddressOut][tokenAddressIn].conversionAccess != ConversionAccessibility.NONE\\n ) {\\n revert InvalidTokenConfigAddresses();\\n }\\n\\n if (\\n (conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) &&\\n conversionConfig.incentive != 0\\n ) {\\n revert NonZeroIncentiveForPrivateConversion();\\n }\\n\\n if (\\n ((conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) ||\\n (conversionConfig.conversionAccess == ConversionAccessibility.ALL)) &&\\n (address(converterNetwork) == address(0))\\n ) {\\n revert InvalidConverterNetwork();\\n }\\n\\n ConversionConfig storage configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n emit ConversionConfigUpdated(\\n tokenAddressIn,\\n tokenAddressOut,\\n configuration.incentive,\\n conversionConfig.incentive,\\n configuration.conversionAccess,\\n conversionConfig.conversionAccess\\n );\\n\\n if (conversionConfig.conversionAccess == ConversionAccessibility.NONE) {\\n delete conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n } else {\\n configuration.incentive = conversionConfig.incentive;\\n configuration.conversionAccess = conversionConfig.conversionAccess;\\n }\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) public view virtual returns (uint256 tokenBalance);\\n\\n /// @dev Operations to perform before sweeping tokens\\n /// @param token Address of the token\\n /// @param amount Amount transferred to address(to)\\n function preSweepToken(address token, uint256 amount) internal virtual {}\\n\\n /// @dev Converts exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return amountOutMantissa Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function _convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 amountOutMantissa) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, amountOutMantissa) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n if (amountOutMantissa < amountOutMinMantissa) {\\n revert AmountOutLowerThanMinRequired(amountOutMantissa, amountOutMinMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for exact amount of tokenAddressOut used for non deflationry tokens\\n /// it is called by convertForExactTokens function\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error DeflationaryTokenNotSupported is thrown if tokenAddressIn is deflationary token\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert DeflationaryTokenNotSupported();\\n }\\n\\n if (actualAmountIn > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n actualAmountOut = amountOutMantissa;\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for the amount of tokenAddressOut used for deflationary tokens\\n /// it is called by convertForExactTokensSupportingFeeOnTransferTokens function\\n /// @notice Advising users to input a smaller amountOutMantissa to avoid potential transaction revert\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n if (amountInMantissa > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, actualAmountOut) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n _doTransferOut(tokenAddressOut, to, actualAmountOut);\\n }\\n\\n /// @dev return actualAmountOut from reserves for tokenAddressOut\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred\\n /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n function _doTransferOut(\\n address tokenAddressOut,\\n address to,\\n uint256 amountConvertedMantissa\\n ) internal {\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountConvertedMantissa) {\\n revert InsufficientPoolLiquidity();\\n }\\n\\n _preTransferHook(tokenAddressOut, amountConvertedMantissa);\\n\\n IERC20Upgradeable tokenOut = IERC20Upgradeable(tokenAddressOut);\\n tokenOut.safeTransfer(to, amountConvertedMantissa);\\n }\\n\\n /// @notice Transfer tokenAddressIn from user to destination\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @return actualAmountIn Actual amount transferred to destination\\n function _doTransferIn(address tokenAddressIn, uint256 amountInMantissa) internal returns (uint256 actualAmountIn) {\\n IERC20Upgradeable tokenIn = IERC20Upgradeable(tokenAddressIn);\\n uint256 balanceBeforeDestination = tokenIn.balanceOf(destinationAddress);\\n tokenIn.safeTransferFrom(msg.sender, destinationAddress, amountInMantissa);\\n uint256 balanceAfterDestination = tokenIn.balanceOf(destinationAddress);\\n actualAmountIn = balanceAfterDestination - balanceBeforeDestination;\\n }\\n\\n /// @dev Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:event Emits PriceOracleUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero\\n function _setPriceOracle(ResilientOracle priceOracle_) internal {\\n ensureNonzeroAddress(address(priceOracle_));\\n emit PriceOracleUpdated(priceOracle, priceOracle_);\\n priceOracle = priceOracle_;\\n }\\n\\n /// @dev Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:event Emits DestinationAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when destination address is zero\\n function _setDestination(address destinationAddress_) internal {\\n ensureNonzeroAddress(destinationAddress_);\\n emit DestinationAddressUpdated(destinationAddress, destinationAddress_);\\n destinationAddress = destinationAddress_;\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:event Emits ConverterNetworkAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n function _setConverterNetwork(IConverterNetwork converterNetwork_) internal {\\n ensureNonzeroAddress(address(converterNetwork_));\\n emit ConverterNetworkAddressUpdated(address(converterNetwork), address(converterNetwork_));\\n converterNetwork = converterNetwork_;\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:event MinAmountToConvertUpdated is emitted in success\\n /// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\n function _setMinAmountToConvert(uint256 minAmountToConvert_) internal {\\n ensureNonzeroValue(minAmountToConvert_);\\n emit MinAmountToConvertUpdated(minAmountToConvert, minAmountToConvert_);\\n minAmountToConvert = minAmountToConvert_;\\n }\\n\\n /// @dev Hook to perform after converting tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param amountIn Amount of tokenIn converted\\n /// @param amountOut Amount of tokenOut converted\\n function _postConversionHook(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n ) internal virtual {}\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n __AccessControlled_init(accessControlManager_);\\n __ReentrancyGuard_init();\\n __AbstractTokenConverter_init_unchained(priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init_unchained(\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n _setPriceOracle(priceOracle_);\\n _setDestination(destinationAddress_);\\n _setMinAmountToConvert(minAmountToConvert_);\\n conversionPaused = false;\\n }\\n\\n /// @dev _updateAssetsState hook to update the states of reserves transferred for the specific comptroller\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n /// @return Amount of asset, for _privateConversion\\n function _updateAssetsState(address comptroller, address asset) internal virtual returns (uint256) {}\\n\\n /// @dev This method is used to convert asset into base asset by converting them with other converters which supports the pair and transfer the funds to\\n /// destination contract as destination's base asset\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset\\n /// @param amountToConvert Amount of the tokenAddressOut transferred to converter\\n function _privateConversion(\\n address comptroller,\\n address tokenAddressOut,\\n uint256 amountToConvert\\n ) internal {\\n address tokenAddressIn = _getDestinationBaseAsset();\\n address _destinationAddress = destinationAddress;\\n uint256 convertedTokenInBalance;\\n if (address(converterNetwork) != address(0)) {\\n (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork\\n .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn);\\n uint256 convertersLength = converterAddresses.length;\\n for (uint256 i; i < convertersLength; ) {\\n if (converterBalances[i] == 0) break;\\n (, uint256 amountIn) = IAbstractTokenConverter(converterAddresses[i]).getUpdatedAmountIn(\\n converterBalances[i],\\n tokenAddressOut,\\n tokenAddressIn\\n );\\n if (amountIn > amountToConvert) {\\n amountIn = amountToConvert;\\n }\\n\\n if (!_validateMinAmountToConvert(amountIn, tokenAddressOut)) {\\n break;\\n }\\n\\n uint256 balanceBefore = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n\\n IERC20Upgradeable(tokenAddressOut).forceApprove(converterAddresses[i], amountIn);\\n IAbstractTokenConverter(converterAddresses[i]).convertExactTokens(\\n amountIn,\\n 0,\\n tokenAddressOut,\\n tokenAddressIn,\\n _destinationAddress\\n );\\n\\n uint256 balanceAfter = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n amountToConvert -= amountIn;\\n convertedTokenInBalance += (balanceAfter - balanceBefore);\\n\\n if (amountToConvert == 0) break;\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n _postPrivateConversionHook(\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance,\\n tokenAddressOut,\\n amountToConvert\\n );\\n }\\n\\n /// @dev This hook is used to update states for the converter after the privateConversion\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressIn Address of the destination's base asset\\n /// @param convertedTokenInBalance Amount of the base asset received after the conversion\\n /// @param tokenAddressOut Address of the asset transferred to other converter in exchange of base asset\\n /// @param convertedTokenOutBalance Amount of tokenAddressOut transferred from this converter\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address tokenAddressOut,\\n uint256 convertedTokenOutBalance\\n ) internal virtual {}\\n\\n /// @notice This hook is used to update the state for asset reserves before transferring tokenOut to user\\n /// @param tokenOutAddress Address of the asset to be transferred to the user\\n /// @param amountOut Amount of tokenAddressOut transferred from this converter\\n function _preTransferHook(address tokenOutAddress, uint256 amountOut) internal virtual {}\\n\\n /// @dev Checks if amount to convert is greater than minimum amount to convert or not\\n /// @param amountIn The amount to convert\\n /// @param tokenAddress Address of the token\\n /// @return isValid true if amount to convert is greater than minimum amount to convert\\n function _validateMinAmountToConvert(uint256 amountIn, address tokenAddress) internal returns (bool isValid) {\\n priceOracle.updateAssetPrice(tokenAddress);\\n uint256 amountInInUsd = (priceOracle.getPrice(tokenAddress) * amountIn) / EXP_SCALE;\\n\\n if (amountInInUsd >= minAmountToConvert) {\\n isValid = true;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountOutMantissa, uint256 tokenInToOutConversion) {\\n if (amountInMantissa == 0) {\\n revert InsufficientInputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n if (address(converterNetwork) != address(0) && (converterNetwork.isTokenConverter(msg.sender))) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n /// amount of tokenAddressOut after including incentive as amountOutMantissa will be greater than actual as it gets\\n /// multiplied by conversionWithIncentive which will be >= 1\\n amountOutMantissa = (amountInMantissa * tokenInToOutConversion) / (EXP_SCALE);\\n }\\n\\n /// @dev To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @dev For user conversions, the function returns an amountInMantissa that is rounded up, ensuring that the equivalent amountInMantissa\\n /// is obtained from users for corresponding amountOutMantissa, preventing any losses to the protocol. However, no rounding up is required for private conversions\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountInMantissa, uint256 tokenInToOutConversion) {\\n if (amountOutMantissa == 0) {\\n revert InsufficientOutputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n\\n bool isPrivateConversion = address(converterNetwork) != address(0) &&\\n converterNetwork.isTokenConverter(msg.sender);\\n if (isPrivateConversion) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n /// amount of tokenAddressIn after considering incentive(i.e. amountInMantissa will be less than actual amountInMantissa if incentive > 0)\\n if (isPrivateConversion) {\\n amountInMantissa =\\n (amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE) /\\n (tokenInUnderlyingPrice * conversionWithIncentive);\\n } else {\\n amountInMantissa = _divRoundingUp(\\n amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE,\\n tokenInUnderlyingPrice * conversionWithIncentive\\n );\\n }\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n }\\n\\n /// @dev Check if msg.sender is allowed to convert as per onlyForPrivateConversions flag\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function _checkPrivateConversion(address tokenAddressIn, address tokenAddressOut) internal view {\\n bool isConverter = (address(converterNetwork) != address(0)) && converterNetwork.isTokenConverter(msg.sender);\\n if (\\n (!(isConverter) &&\\n (conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS))\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n }\\n\\n /// @dev To check, is conversion paused\\n /// @custom:error ConversionTokensPaused is thrown when token conversion is paused\\n function _checkConversionPaused() internal view {\\n if (conversionPaused) {\\n revert ConversionTokensPaused();\\n }\\n }\\n\\n /// @dev Get base asset address of the destination contract\\n /// @return Address of the base asset\\n function _getDestinationBaseAsset() internal view virtual returns (address) {}\\n\\n /// @dev Performs division where the result is rounded up\\n /// @param numerator The numerator of the division operation\\n /// @param denominator The denominator of the division operation. Must be non-zero\\n /// @return The result of the division, rounded up\\n function _divRoundingUp(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\\n return (numerator + denominator - 1) / denominator;\\n }\\n}\\n\",\"keccak256\":\"0xf87680dcb5a46a16663923c575661eda78ef57d29b7d78a85ddac00062426e18\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/IAbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @notice Interface for AbstractTokenConverter\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ninterface IAbstractTokenConverter {\\n /// @notice This enum define the all possible ways of conversion can happen\\n enum ConversionAccessibility {\\n NONE, // Conversion is disable for the pair\\n ALL, // Conversion is enable for private conversion and users\\n ONLY_FOR_CONVERTERS, // Conversion is enable only for private conversion\\n ONLY_FOR_USERS // Conversion is enable only for users\\n }\\n\\n /// @notice This struct represents the configuration for a token conversion.\\n struct ConversionConfig {\\n /// incentive on conversion of tokens in mantissa i.e 10% incentive would be 0.1 * 1e18\\n uint256 incentive;\\n /// enable or disable conversion for users or converters or both or none\\n ConversionAccessibility conversionAccess;\\n }\\n\\n /// @notice Pause conversion of tokens\\n function pauseConversion() external;\\n\\n /// @notice Resume conversion of tokens.\\n function resumeConversion() external;\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n function setPriceOracle(ResilientOracle priceOracle_) external;\\n\\n /// @notice Set the configuration for new or existing convert pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) external;\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Get the configuration for the pair of the tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return incentives Percentage of incentives to be distributed for the pair of tokens\\n /// @return conversionAccess Accessibility for the pair of tokens\\n function conversionConfigurations(address tokenAddressIn, address tokenAddressOut)\\n external\\n returns (uint256 incentives, ConversionAccessibility conversionAccess);\\n\\n /// @notice Get the address of the converterNetwork\\n function converterNetwork() external returns (IConverterNetwork converterNetwork);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) external view returns (uint256 tokenBalance);\\n}\\n\",\"keccak256\":\"0x7852d4f8a6dd1c80d14342f8ff2e26f723eb00c888e9a9e50a5fe8f95c59200c\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/SingleTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\n\\nimport { AbstractTokenConverter } from \\\"./AbstractTokenConverter.sol\\\";\\n\\n/// @title SingleTokenConverter\\n/// @author Venus\\n/// @notice SingleTokenConverter used for token conversions and sends received tokens\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ncontract SingleTokenConverter is AbstractTokenConverter {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Address of the base asset token\\n address public baseAsset;\\n\\n /// @notice Emitted when base asset is updated\\n event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset);\\n\\n /// @notice Emmitted after the funds transferred to the destination address\\n event AssetTransferredToDestination(\\n address indexed receiver,\\n address indexed comptroller,\\n address indexed asset,\\n uint256 amount\\n );\\n\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor() {\\n // Note that the contract is upgradeable. Use initialize() or reinitializers\\n // to set the state variables.\\n _disableInitializers();\\n }\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param baseAsset_ Address of the base asset\\n /// @param minAmountToConvert_ Minimum amount to convert\\n function initialize(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n address baseAsset_,\\n uint256 minAmountToConvert_\\n ) public initializer {\\n _setBaseAsset(baseAsset_);\\n\\n // Initialize AbstractTokenConverter\\n __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @notice Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:access Only Governance\\n function setBaseAsset(address baseAsset_) external onlyOwner {\\n _setBaseAsset(baseAsset_);\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param tokenAddress Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n tokenBalance = token.balanceOf(address(this));\\n }\\n\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address.\\n /// @return balanceLeft Amount of asset, for _privateConversion\\n // solhint-disable-next-line\\n function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) {\\n IERC20Upgradeable token = IERC20Upgradeable(asset);\\n uint256 balance = token.balanceOf(address(this));\\n balanceLeft = balance;\\n\\n if (asset == baseAsset) {\\n balanceLeft = 0;\\n token.safeTransfer(destinationAddress, balance);\\n emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance);\\n }\\n }\\n\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address,\\n uint256\\n ) internal override {\\n if (convertedTokenInBalance > 0) {\\n emit AssetTransferredToDestination(\\n destinationAddress,\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance\\n );\\n }\\n }\\n\\n /// @dev Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n /// @custom:event BaseAssetUpdated is emitted on success\\n function _setBaseAsset(address baseAsset_) internal {\\n ensureNonzeroAddress(baseAsset_);\\n emit BaseAssetUpdated(baseAsset, baseAsset_);\\n baseAsset = baseAsset_;\\n }\\n\\n /// @dev Get base asset address\\n /// @return destinationBaseAsset Address of the base asset(baseAsset)\\n function _getDestinationBaseAsset() internal view override returns (address destinationBaseAsset) {\\n destinationBaseAsset = baseAsset;\\n }\\n}\\n\",\"keccak256\":\"0x907f72b2fe32429d4a0fc95e4daee85e313be2593a0ae5734559f019f66a2b37\",\"license\":\"BSD-3-Clause\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "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", + "numDeployments": 3, + "solcInputHash": "dceb6d0de70f90933a7f2cdf26a987ca", + "metadata": "{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountInHigherThanMax\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountInMismatched\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountOutLowerThanMinRequired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountOutMismatched\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionConfigNotEnabled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionEnabledOnlyForPrivateConversions\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensActive\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensPaused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DeflationaryTokenNotSupported\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DirectTransferBaseAssetNotAllowed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxIncentive\",\"type\":\"uint256\"}],\"name\":\"IncentiveTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InputLengthMisMatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientInputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientOutputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientPoolLiquidity\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidConverterNetwork\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidMinimumAmountToConvert\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidToAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenConfigAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NonZeroIncentiveForPrivateConversion\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"SameAssetDirectTransferNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SameBaseAssetNotAllowed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"calledContract\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"methodSignature\",\"type\":\"string\"}],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddressNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroValueNotAllowed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"AssetTransferredToDestination\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"AssetsDirectTransferUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldBaseAsset\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newBaseAsset\",\"type\":\"address\"}],\"name\":\"BaseAssetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"oldAccess\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"newAccess\",\"type\":\"uint8\"}],\"name\":\"ConversionConfigUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionResumed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldConverterNetwork\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"converterNetwork\",\"type\":\"address\"}],\"name\":\"ConverterNetworkAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldDestinationAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"}],\"name\":\"DestinationAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldMinAmountToConvert\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newMinAmountToConvert\",\"type\":\"uint256\"}],\"name\":\"MinAmountToConvertUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldAccessControlManager\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAccessControlManager\",\"type\":\"address\"}],\"name\":\"NewAccessControlManager\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"oldPriceOracle\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle\",\"type\":\"address\"}],\"name\":\"PriceOracleUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SweepToken\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MAX_INCENTIVE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"accessControlManager\",\"outputs\":[{\"internalType\":\"contract IAccessControlManagerV8\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"assetsDirectTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"baseAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"conversionConfigurations\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"conversionPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"converterNetwork\",\"outputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"destinationAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"},{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minAmountToConvert\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"priceOracle\",\"outputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"}],\"name\":\"setAccessControlManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"assets\",\"type\":\"address[]\"},{\"internalType\":\"bool[]\",\"name\":\"values\",\"type\":\"bool[]\"}],\"name\":\"setAssetsDirectTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"}],\"name\":\"setBaseAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig\",\"name\":\"conversionConfig\",\"type\":\"tuple\"}],\"name\":\"setConversionConfig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"tokenAddressesOut\",\"type\":\"address[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig[]\",\"name\":\"conversionConfigs\",\"type\":\"tuple[]\"}],\"name\":\"setConversionConfigs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"converterNetwork_\",\"type\":\"address\"}],\"name\":\"setConverterNetwork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"}],\"name\":\"setDestination\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"setMinAmountToConvert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"}],\"name\":\"setPriceOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sweepToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"updateAssetsState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Venus\",\"custom:security-contact\":\"https://github.com/VenusProtocol/protocol-reserve#discussion\",\"errors\":{\"SameAssetDirectTransferNotAllowed(address,bool)\":[{\"params\":{\"asset\":\"The asset address whose `assetDirectTransfer` value went to be set\",\"value\":\"The value to be set\"}}]},\"events\":{\"Initialized(uint8)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"}},\"kind\":\"dev\",\"methods\":{\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"balanceOf(address)\":{\"params\":{\"tokenAddress\":\"Address of the token\"},\"returns\":{\"tokenBalance\":\"Balance of the token the contract has\"}},\"constructor\":{\"custom:oz-upgrades-unsafe-allow\":\"constructor\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissaAmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissaAmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\",\"custom:event\":\"Emits ConvertedForExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\",\"custom:event\":\"Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"getAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"getUpdatedAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getUpdatedAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"initialize(address,address,address,address,uint256)\":{\"params\":{\"accessControlManager_\":\"Access control manager contract address\",\"baseAsset_\":\"Address of the base asset\",\"destinationAddress_\":\"Address at all incoming tokens will transferred to\",\"minAmountToConvert_\":\"Minimum amount to convert\",\"priceOracle_\":\"Resilient oracle address\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pauseConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensPaused thrown when conversion is already paused\",\"custom:event\":\"Emits ConversionPaused on success\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"resumeConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensActive thrown when conversion is already active\",\"custom:event\":\"Emits ConversionResumed on success\"},\"setAccessControlManager(address)\":{\"custom:access\":\"Only Governance\",\"custom:event\":\"Emits NewAccessControlManager event\",\"details\":\"Admin function to set address of AccessControlManager\",\"params\":{\"accessControlManager_\":\"The new address of the AccessControlManager\"}},\"setAssetsDirectTransfer(address[],bool[])\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"InputLengthMisMatch thrown when assets and values array lengths don't match\",\"custom:event\":\"AssetsDirectTransferUpdated emits on success\",\"params\":{\"assets\":\"Addresses of the assets need to be added or removed for direct transfer\",\"values\":\"Boolean value to indicate whether direct transfer is allowed for each asset.\"}},\"setBaseAsset(address)\":{\"custom:access\":\"Only Governance\",\"custom:error\":\"ZeroAddressNotAllowed is thrown when address is zeroSameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\",\"custom:event\":\"BaseAssetUpdated is emitted on success\",\"params\":{\"baseAsset_\":\"The new address of the base asset\"}},\"setConversionConfig(address,address,(uint256,uint8))\":{\"custom:access\":\"Controlled by AccessControlManager\",\"custom:error\":\"Unauthorized error is thrown when the call is not authorized by AccessControlManagerZeroAddressNotAllowed is thrown when pool registry address is zeroNonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\",\"custom:event\":\"Emits ConversionConfigUpdated event on success\",\"params\":{\"conversionConfig\":\"ConversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressOut\":\"Address of tokenOut\"}},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"custom:error\":\"InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\",\"params\":{\"conversionConfigs\":\"Array of conversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressesOut\":\"Array of addresses of tokenOut\"}},\"setConverterNetwork(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"converterNetwork_\":\"The converterNetwork address to be set\"}},\"setDestination(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"destinationAddress_\":\"The new destination address to be set\"}},\"setMinAmountToConvert(uint256)\":{\"custom:access\":\"Only Governance\",\"params\":{\"minAmountToConvert_\":\"Min amount to convert\"}},\"setPriceOracle(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"priceOracle_\":\"Address of the new price oracle to set\"}},\"sweepToken(address,address,uint256)\":{\"custom:access\":\"Only Governance\",\"custom:error\":\"ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\",\"custom:event\":\"Emits SweepToken event on success\",\"params\":{\"amount\":\"The amount to transfer\",\"to\":\"The address to which tokens will be transferred\",\"tokenAddress\":\"The address of the ERC-20 token to sweep\"}},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner.\"},\"updateAssetsState(address,address)\":{\"details\":\"This function is called by protocolShareReservecall _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\",\"params\":{\"asset\":\"Asset address\",\"comptroller\":\"Comptroller address (pool)\"}}},\"stateVariables\":{\"assetsDirectTransfer\":{\"details\":\"Asset -> bool(should transfer directly on true)\"}},\"title\":\"SingleTokenConverter\",\"version\":1},\"userdoc\":{\"errors\":{\"AmountInHigherThanMax(uint256,uint256)\":[{\"notice\":\"Thrown when amountIn is higher than amountInMax\"}],\"AmountInMismatched()\":[{\"notice\":\"Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\"}],\"AmountOutLowerThanMinRequired(uint256,uint256)\":[{\"notice\":\"Thrown when amountOut is lower than amountOutMin\"}],\"AmountOutMismatched()\":[{\"notice\":\"Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\"}],\"ConversionConfigNotEnabled()\":[{\"notice\":\"Thrown when conversion is disabled or config does not exist for given pair\"}],\"ConversionEnabledOnlyForPrivateConversions()\":[{\"notice\":\"Thrown when conversion is enabled only for private conversions\"}],\"ConversionTokensActive()\":[{\"notice\":\"Thrown when conversion is Active\"}],\"ConversionTokensPaused()\":[{\"notice\":\"Thrown when conversion is paused\"}],\"DeflationaryTokenNotSupported()\":[{\"notice\":\"Thrown when using convertForExactTokens deflationary tokens\"}],\"DirectTransferBaseAssetNotAllowed()\":[{\"notice\":\"Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection\"}],\"IncentiveTooHigh(uint256,uint256)\":[{\"notice\":\"Thrown when incentive is higher than the MAX_INCENTIVE\"}],\"InputLengthMisMatch()\":[{\"notice\":\"Thrown when there is a mismatch in the length of input arrays\"}],\"InsufficientInputAmount()\":[{\"notice\":\"Thrown when given input amount is zero\"}],\"InsufficientOutputAmount()\":[{\"notice\":\"Thrown when given output amount is zero\"}],\"InsufficientPoolLiquidity()\":[{\"notice\":\"Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\"}],\"InvalidConverterNetwork()\":[{\"notice\":\"When address of the ConverterNetwork is not set or Zero address\"}],\"InvalidMinimumAmountToConvert()\":[{\"notice\":\"Thrown when minimum amount to convert is zero\"}],\"InvalidToAddress()\":[{\"notice\":\"Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\"}],\"InvalidTokenConfigAddresses()\":[{\"notice\":\"Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\"}],\"NonZeroIncentiveForPrivateConversion()\":[{\"notice\":\"Thrown when trying to set non zero incentive for private conversion\"}],\"SameAssetDirectTransferNotAllowed(address,bool)\":[{\"notice\":\"Thrown when the `assetsDirectTransfer[asset]` is already `value`\"}],\"SameBaseAssetNotAllowed()\":[{\"notice\":\"Thrown when the base asset is the same as the new base asset\"}],\"Unauthorized(address,address,string)\":[{\"notice\":\"Thrown when the action is prohibited by AccessControlManager\"}],\"ZeroAddressNotAllowed()\":[{\"notice\":\"Thrown if the supplied address is a zero address where it is not allowed\"}],\"ZeroValueNotAllowed()\":[{\"notice\":\"Thrown if the supplied value is 0 where it is not allowed\"}]},\"events\":{\"AssetTransferredToDestination(address,address,address,uint256)\":{\"notice\":\"Emmitted after the funds transferred to the destination address\"},\"AssetsDirectTransferUpdated(address,address,bool)\":{\"notice\":\"Emitted after the assetsDirectTransfer mapping is updated\"},\"BaseAssetUpdated(address,address)\":{\"notice\":\"Emitted when base asset is updated\"},\"ConversionConfigUpdated(address,address,uint256,uint256,uint8,uint8)\":{\"notice\":\"Emitted when config is updated for tokens pair\"},\"ConversionPaused(address)\":{\"notice\":\"Emitted when conversion is paused\"},\"ConversionResumed(address)\":{\"notice\":\"Emitted when conversion is unpaused\"},\"ConvertedExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens\"},\"ConvertedExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\"},\"ConvertedForExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens\"},\"ConvertedForExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\"},\"ConverterNetworkAddressUpdated(address,address)\":{\"notice\":\"Emitted when converterNetwork address is updated\"},\"DestinationAddressUpdated(address,address)\":{\"notice\":\"Emitted when destination address is updated\"},\"MinAmountToConvertUpdated(uint256,uint256)\":{\"notice\":\"Emitted when minimum amount to convert is updated\"},\"NewAccessControlManager(address,address)\":{\"notice\":\"Emitted when access control manager contract address is changed\"},\"PriceOracleUpdated(address,address)\":{\"notice\":\"Emitted when price oracle address is updated\"},\"SweepToken(address,address,uint256)\":{\"notice\":\"Event emitted when tokens are swept\"}},\"kind\":\"user\",\"methods\":{\"MAX_INCENTIVE()\":{\"notice\":\"Maximum incentive could be\"},\"accessControlManager()\":{\"notice\":\"Returns the address of the access control manager contract\"},\"assetsDirectTransfer(address)\":{\"notice\":\"The mapping contains the assets which are sent to destination directly\"},\"balanceOf(address)\":{\"notice\":\"Get the balance for specific token\"},\"baseAsset()\":{\"notice\":\"Address of the base asset token\"},\"conversionConfigurations(address,address)\":{\"notice\":\"conversion configurations for the existing pairs\"},\"conversionPaused()\":{\"notice\":\"Boolean for if conversion is paused\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract, otherwise the amount is adjusted\"},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted. The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\"},\"converterNetwork()\":{\"notice\":\"Address of the converterNetwork contract\"},\"destinationAddress()\":{\"notice\":\"Address that all incoming tokens are transferred to\"},\"getAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut. This function does not account for potential token transfer fees(in case of deflationary tokens)\"},\"getAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn. This function does not account for potential token transfer fees(in case of deflationary tokens)The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\"},\"getUpdatedAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\"},\"getUpdatedAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\"},\"minAmountToConvert()\":{\"notice\":\"Min amount to convert for private conversions. Defined in USD, with 18 decimals\"},\"pauseConversion()\":{\"notice\":\"Pause conversion of tokens\"},\"priceOracle()\":{\"notice\":\"Venus price oracle contract\"},\"resumeConversion()\":{\"notice\":\"Resume conversion of tokens.\"},\"setAccessControlManager(address)\":{\"notice\":\"Sets the address of AccessControlManager\"},\"setAssetsDirectTransfer(address[],bool[])\":{\"notice\":\"Update the assetsDirectTransfer mapping\"},\"setBaseAsset(address)\":{\"notice\":\"Sets the base asset for the contract\"},\"setConversionConfig(address,address,(uint256,uint8))\":{\"notice\":\"Set the configuration for new or existing conversion pair\"},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"notice\":\"Batch sets the conversion configurations\"},\"setConverterNetwork(address)\":{\"notice\":\"Sets a converter network contract address\"},\"setDestination(address)\":{\"notice\":\"Sets a new destination address\"},\"setMinAmountToConvert(uint256)\":{\"notice\":\"Min amount to convert setter\"},\"setPriceOracle(address)\":{\"notice\":\"Sets a new price oracle\"},\"sweepToken(address,address,uint256)\":{\"notice\":\"To sweep ERC20 tokens and transfer them to user(to address)\"},\"updateAssetsState(address,address)\":{\"notice\":\"This method updated the states of this contract after getting funds from PSR after settling the amount(if any) through privateConversion between converters\"}},\"notice\":\"SingleTokenConverter used for token conversions and sends received tokens\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/TokenConverter/SingleTokenConverter.sol\":\"SingleTokenConverter\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./OwnableUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership} and {acceptOwnership}.\\n *\\n * This module is used through inheritance. It will make available all functions\\n * from parent (Ownable).\\n */\\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\\n function __Ownable2Step_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable2Step_init_unchained() internal onlyInitializing {\\n }\\n address private _pendingOwner;\\n\\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Returns the address of the pending owner.\\n */\\n function pendingOwner() public view virtual returns (address) {\\n return _pendingOwner;\\n }\\n\\n /**\\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual override onlyOwner {\\n _pendingOwner = newOwner;\\n emit OwnershipTransferStarted(owner(), newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual override {\\n delete _pendingOwner;\\n super._transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev The new owner accepts the ownership transfer.\\n */\\n function acceptOwnership() public virtual {\\n address sender = _msgSender();\\n require(pendingOwner() == sender, \\\"Ownable2Step: caller is not the new owner\\\");\\n _transferOwnership(sender);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x84efb8889801b0ac817324aff6acc691d07bbee816b671817132911d287a8c63\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n function __Ownable_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable_init_unchained() internal onlyInitializing {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby disabling any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x4075622496acc77fd6d4de4cc30a8577a744d5c75afad33fdeacf1704d6eda98\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts.\\n *\\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n * constructor.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n * are added through upgrades and that require initialization.\\n *\\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n * cannot be nested. If one is invoked in the context of another, execution will revert.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n *\\n * WARNING: setting the version to 255 will prevent any future reinitialization.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n *\\n * Emits an {Initialized} event the first time it is successfully executed.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized != type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n\\n /**\\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n */\\n function _getInitializedVersion() internal view returns (uint8) {\\n return _initialized;\\n }\\n\\n /**\\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n */\\n function _isInitializing() internal view returns (bool) {\\n return _initializing;\\n }\\n}\\n\",\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state.\\n */\\n function __Pausable_init() internal onlyInitializing {\\n __Pausable_init_unchained();\\n }\\n\\n function __Pausable_init_unchained() internal onlyInitializing {\\n _paused = false;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused() {\\n _requireNotPaused();\\n _;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier whenPaused() {\\n _requirePaused();\\n _;\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused() public view virtual returns (bool) {\\n return _paused;\\n }\\n\\n /**\\n * @dev Throws if the contract is paused.\\n */\\n function _requireNotPaused() internal view virtual {\\n require(!paused(), \\\"Pausable: paused\\\");\\n }\\n\\n /**\\n * @dev Throws if the contract is not paused.\\n */\\n function _requirePaused() internal view virtual {\\n require(paused(), \\\"Pausable: not paused\\\");\\n }\\n\\n /**\\n * @dev Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(_msgSender());\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n function __ReentrancyGuard_init() internal onlyInitializing {\\n __ReentrancyGuard_init_unchained();\\n }\\n\\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == _ENTERED;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xb82ef33f43b6b96109687d91b39c94573fdccaaa423fe28e8ba0977b31c023e0\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20PermitUpgradeable {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xd60f939a3ca0199014d079b4dd66aa757954334947d81eb5c1d35d7a83061ab3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\nimport \\\"../extensions/IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20Upgradeable {\\n using AddressUpgradeable for address;\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\\n * Revert on invalid signature.\\n */\\n function safePermit(\\n IERC20PermitUpgradeable token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return\\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));\\n }\\n}\\n\",\"keccak256\":\"0x23b997be73d3dd46885262704f0f8cfc7273fdadfe303d37969a9561373972b5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n *\\n * Furthermore, `isContract` will also return true if the target contract within\\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n * which only has an effect at the end of a transaction.\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal onlyInitializing {\\n }\\n\\n function __Context_init_unchained() internal onlyInitializing {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl {\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\"},\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\\\";\\n\\nimport \\\"./IAccessControlManagerV8.sol\\\";\\n\\n/**\\n * @title AccessControlledV8\\n * @author Venus\\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.8.13)\\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\\n */\\nabstract contract AccessControlledV8 is Initializable, Ownable2StepUpgradeable {\\n /// @notice Access control manager contract\\n IAccessControlManagerV8 private _accessControlManager;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n\\n /// @notice Emitted when access control manager contract address is changed\\n event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\\n\\n /// @notice Thrown when the action is prohibited by AccessControlManager\\n error Unauthorized(address sender, address calledContract, string methodSignature);\\n\\n function __AccessControlled_init(address accessControlManager_) internal onlyInitializing {\\n __Ownable2Step_init();\\n __AccessControlled_init_unchained(accessControlManager_);\\n }\\n\\n function __AccessControlled_init_unchained(address accessControlManager_) internal onlyInitializing {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Sets the address of AccessControlManager\\n * @dev Admin function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n * @custom:event Emits NewAccessControlManager event\\n * @custom:access Only Governance\\n */\\n function setAccessControlManager(address accessControlManager_) external onlyOwner {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Returns the address of the access control manager contract\\n */\\n function accessControlManager() external view returns (IAccessControlManagerV8) {\\n return _accessControlManager;\\n }\\n\\n /**\\n * @dev Internal function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n */\\n function _setAccessControlManager(address accessControlManager_) internal {\\n require(address(accessControlManager_) != address(0), \\\"invalid acess control manager address\\\");\\n address oldAccessControlManager = address(_accessControlManager);\\n _accessControlManager = IAccessControlManagerV8(accessControlManager_);\\n emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\\n }\\n\\n /**\\n * @notice Reverts if the call is not allowed by AccessControlManager\\n * @param signature Method signature\\n */\\n function _checkAccessAllowed(string memory signature) internal view {\\n bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\\n\\n if (!isAllowedToCall) {\\n revert Unauthorized(msg.sender, address(this), signature);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0dcf283925f4dddc23ca0ee71d2cb96a9dd6e4cf08061b69fde1697ea39dc514\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/access/IAccessControl.sol\\\";\\n\\n/**\\n * @title IAccessControlManagerV8\\n * @author Venus\\n * @notice Interface implemented by the `AccessControlManagerV8` contract.\\n */\\ninterface IAccessControlManagerV8 is IAccessControl {\\n function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\\n\\n function revokeCallPermission(\\n address contractAddress,\\n string calldata functionSig,\\n address accountToRevoke\\n ) external;\\n\\n function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\\n\\n function hasPermission(\\n address account,\\n address contractAddress,\\n string calldata functionSig\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xaa29b098440d0b3a131c5ecdf25ce548790c1b5ac7bf9b5c0264b6af6f7a1e0b\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/ResilientOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\n// SPDX-FileCopyrightText: 2022 Venus\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\nimport \\\"./interfaces/VBep20Interface.sol\\\";\\nimport \\\"./interfaces/OracleInterface.sol\\\";\\nimport \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\n\\n/**\\n * @title ResilientOracle\\n * @author Venus\\n * @notice The Resilient Oracle is the main contract that the protocol uses to fetch prices of assets.\\n *\\n * DeFi protocols are vulnerable to price oracle failures including oracle manipulation and incorrectly\\n * reported prices. If only one oracle is used, this creates a single point of failure and opens a vector\\n * for attacking the protocol.\\n *\\n * The Resilient Oracle uses multiple sources and fallback mechanisms to provide accurate prices and protect\\n * the protocol from oracle attacks. Currently it includes integrations with Chainlink, Pyth, Binance Oracle\\n * and TWAP (Time-Weighted Average Price) oracles. TWAP uses PancakeSwap as the on-chain price source.\\n *\\n * For every market (vToken) we configure the main, pivot and fallback oracles. The oracles are configured per\\n * vToken's underlying asset address. The main oracle oracle is the most trustworthy price source, the pivot\\n * oracle is used as a loose sanity checker and the fallback oracle is used as a backup price source.\\n *\\n * To validate prices returned from two oracles, we use an upper and lower bound ratio that is set for every\\n * market. The upper bound ratio represents the deviation between reported price (the price that\\u2019s being\\n * validated) and the anchor price (the price we are validating against) above which the reported price will\\n * be invalidated. The lower bound ratio presents the deviation between reported price and anchor price below\\n * which the reported price will be invalidated. So for oracle price to be considered valid the below statement\\n * should be true:\\n\\n```\\nanchorRatio = anchorPrice/reporterPrice\\nisValid = anchorRatio <= upperBoundAnchorRatio && anchorRatio >= lowerBoundAnchorRatio\\n```\\n\\n * In most cases, Chainlink is used as the main oracle, TWAP or Pyth oracles are used as the pivot oracle depending\\n * on which supports the given market and Binance oracle is used as the fallback oracle. For some markets we may\\n * use Pyth or TWAP as the main oracle if the token price is not supported by Chainlink or Binance oracles.\\n *\\n * For a fetched price to be valid it must be positive and not stagnant. If the price is invalid then we consider the\\n * oracle to be stagnant and treat it like it's disabled.\\n */\\ncontract ResilientOracle is PausableUpgradeable, AccessControlledV8, ResilientOracleInterface {\\n /**\\n * @dev Oracle roles:\\n * **main**: The most trustworthy price source\\n * **pivot**: Price oracle used as a loose sanity checker\\n * **fallback**: The backup source when main oracle price is invalidated\\n */\\n enum OracleRole {\\n MAIN,\\n PIVOT,\\n FALLBACK\\n }\\n\\n struct TokenConfig {\\n /// @notice asset address\\n address asset;\\n /// @notice `oracles` stores the oracles based on their role in the following order:\\n /// [main, pivot, fallback],\\n /// It can be indexed with the corresponding enum OracleRole value\\n address[3] oracles;\\n /// @notice `enableFlagsForOracles` stores the enabled state\\n /// for each oracle in the same order as `oracles`\\n bool[3] enableFlagsForOracles;\\n }\\n\\n uint256 public constant INVALID_PRICE = 0;\\n\\n /// @notice Native market address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable nativeMarket;\\n\\n /// @notice VAI address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable vai;\\n\\n /// @notice Set this as asset address for Native token on each chain.This is the underlying for vBNB (on bsc)\\n /// and can serve as any underlying asset of a market that supports native tokens\\n address public constant NATIVE_TOKEN_ADDR = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\\n\\n /// @notice Bound validator contract address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n BoundValidatorInterface public immutable boundValidator;\\n\\n mapping(address => TokenConfig) private tokenConfigs;\\n\\n event TokenConfigAdded(\\n address indexed asset,\\n address indexed mainOracle,\\n address indexed pivotOracle,\\n address fallbackOracle\\n );\\n\\n /// Event emitted when an oracle is set\\n event OracleSet(address indexed asset, address indexed oracle, uint256 indexed role);\\n\\n /// Event emitted when an oracle is enabled or disabled\\n event OracleEnabled(address indexed asset, uint256 indexed role, bool indexed enable);\\n\\n /**\\n * @notice Checks whether an address is null or not\\n */\\n modifier notNullAddress(address someone) {\\n if (someone == address(0)) revert(\\\"can't be zero address\\\");\\n _;\\n }\\n\\n /**\\n * @notice Checks whether token config exists by checking whether asset is null address\\n * @dev address can't be null, so it's suitable to be used to check the validity of the config\\n * @param asset asset address\\n */\\n modifier checkTokenConfigExistence(address asset) {\\n if (tokenConfigs[asset].asset == address(0)) revert(\\\"token config must exist\\\");\\n _;\\n }\\n\\n /// @notice Constructor for the implementation contract. Sets immutable variables.\\n /// @dev nativeMarketAddress can be address(0) if on the chain we do not support native market\\n /// (e.g vETH on ethereum would not be supported, only vWETH)\\n /// @param nativeMarketAddress The address of a native market (for bsc it would be vBNB address)\\n /// @param vaiAddress The address of the VAI token (if there is VAI on the deployed chain).\\n /// Set to address(0) of VAI is not existent.\\n /// @param _boundValidator Address of the bound validator contract\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor(\\n address nativeMarketAddress,\\n address vaiAddress,\\n BoundValidatorInterface _boundValidator\\n ) notNullAddress(address(_boundValidator)) {\\n nativeMarket = nativeMarketAddress;\\n vai = vaiAddress;\\n boundValidator = _boundValidator;\\n\\n _disableInitializers();\\n }\\n\\n /**\\n * @notice Initializes the contract admin and sets the BoundValidator contract address\\n * @param accessControlManager_ Address of the access control manager contract\\n */\\n function initialize(address accessControlManager_) external initializer {\\n __AccessControlled_init(accessControlManager_);\\n __Pausable_init();\\n }\\n\\n /**\\n * @notice Pauses oracle\\n * @custom:access Only Governance\\n */\\n function pause() external {\\n _checkAccessAllowed(\\\"pause()\\\");\\n _pause();\\n }\\n\\n /**\\n * @notice Unpauses oracle\\n * @custom:access Only Governance\\n */\\n function unpause() external {\\n _checkAccessAllowed(\\\"unpause()\\\");\\n _unpause();\\n }\\n\\n /**\\n * @notice Batch sets token configs\\n * @param tokenConfigs_ Token config array\\n * @custom:access Only Governance\\n * @custom:error Throws a length error if the length of the token configs array is 0\\n */\\n function setTokenConfigs(TokenConfig[] memory tokenConfigs_) external {\\n if (tokenConfigs_.length == 0) revert(\\\"length can't be 0\\\");\\n uint256 numTokenConfigs = tokenConfigs_.length;\\n for (uint256 i; i < numTokenConfigs; ) {\\n setTokenConfig(tokenConfigs_[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /**\\n * @notice Sets oracle for a given asset and role.\\n * @dev Supplied asset **must** exist and main oracle may not be null\\n * @param asset Asset address\\n * @param oracle Oracle address\\n * @param role Oracle role\\n * @custom:access Only Governance\\n * @custom:error Null address error if main-role oracle address is null\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n * @custom:event Emits OracleSet event with asset address, oracle address and role of the oracle for the asset\\n */\\n function setOracle(\\n address asset,\\n address oracle,\\n OracleRole role\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"setOracle(address,address,uint8)\\\");\\n if (oracle == address(0) && role == OracleRole.MAIN) revert(\\\"can't set zero address to main oracle\\\");\\n tokenConfigs[asset].oracles[uint256(role)] = oracle;\\n emit OracleSet(asset, oracle, uint256(role));\\n }\\n\\n /**\\n * @notice Enables/ disables oracle for the input asset. Token config for the input asset **must** exist\\n * @dev Configuration for the asset **must** already exist and the asset cannot be 0 address\\n * @param asset Asset address\\n * @param role Oracle role\\n * @param enable Enabled boolean of the oracle\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n */\\n function enableOracle(\\n address asset,\\n OracleRole role,\\n bool enable\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"enableOracle(address,uint8,bool)\\\");\\n tokenConfigs[asset].enableFlagsForOracles[uint256(role)] = enable;\\n emit OracleEnabled(asset, uint256(role), enable);\\n }\\n\\n /**\\n * @notice Updates the TWAP pivot oracle price.\\n * @dev This function should always be called before calling getUnderlyingPrice\\n * @param vToken vToken address\\n */\\n function updatePrice(address vToken) external override {\\n address asset = _getUnderlyingAsset(vToken);\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @notice Updates the pivot oracle price. Currently using TWAP\\n * @dev This function should always be called before calling getPrice\\n * @param asset asset address\\n */\\n function updateAssetPrice(address asset) external {\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @dev Gets token config by asset address\\n * @param asset asset address\\n * @return tokenConfig Config for the asset\\n */\\n function getTokenConfig(address asset) external view returns (TokenConfig memory) {\\n return tokenConfigs[asset];\\n }\\n\\n /**\\n * @notice Gets price of the underlying asset for a given vToken. Validation flow:\\n * - Check if the oracle is paused globally\\n * - Validate price from main oracle against pivot oracle\\n * - Validate price from fallback oracle against pivot oracle if the first validation failed\\n * - Validate price from main oracle against fallback oracle if the second validation failed\\n * In the case that the pivot oracle is not available but main price is available and validation is successful,\\n * main oracle price is returned.\\n * @param vToken vToken address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getUnderlyingPrice(address vToken) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n\\n address asset = _getUnderlyingAsset(vToken);\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Gets price of the asset\\n * @param asset asset address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getPrice(address asset) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Sets/resets single token configs.\\n * @dev main oracle **must not** be a null address\\n * @param tokenConfig Token config struct\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress is thrown if asset address is null\\n * @custom:error NotNullAddress is thrown if main-role oracle address for asset is null\\n * @custom:event Emits TokenConfigAdded event when the asset config is set successfully by the authorized account\\n */\\n function setTokenConfig(\\n TokenConfig memory tokenConfig\\n ) public notNullAddress(tokenConfig.asset) notNullAddress(tokenConfig.oracles[uint256(OracleRole.MAIN)]) {\\n _checkAccessAllowed(\\\"setTokenConfig(TokenConfig)\\\");\\n\\n tokenConfigs[tokenConfig.asset] = tokenConfig;\\n emit TokenConfigAdded(\\n tokenConfig.asset,\\n tokenConfig.oracles[uint256(OracleRole.MAIN)],\\n tokenConfig.oracles[uint256(OracleRole.PIVOT)],\\n tokenConfig.oracles[uint256(OracleRole.FALLBACK)]\\n );\\n }\\n\\n /**\\n * @notice Gets oracle and enabled status by asset address\\n * @param asset asset address\\n * @param role Oracle role\\n * @return oracle Oracle address based on role\\n * @return enabled Enabled flag of the oracle based on token config\\n */\\n function getOracle(address asset, OracleRole role) public view returns (address oracle, bool enabled) {\\n oracle = tokenConfigs[asset].oracles[uint256(role)];\\n enabled = tokenConfigs[asset].enableFlagsForOracles[uint256(role)];\\n }\\n\\n function _getPrice(address asset) internal view returns (uint256) {\\n uint256 pivotPrice = INVALID_PRICE;\\n\\n // Get pivot oracle price, Invalid price if not available or error\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracleEnabled && pivotOracle != address(0)) {\\n try OracleInterface(pivotOracle).getPrice(asset) returns (uint256 pricePivot) {\\n pivotPrice = pricePivot;\\n } catch {}\\n }\\n\\n // Compare main price and pivot price, return main price and if validation was successful\\n // note: In case pivot oracle is not available but main price is available and\\n // validation is successful, the main oracle price is returned.\\n (uint256 mainPrice, bool validatedPivotMain) = _getMainOraclePrice(\\n asset,\\n pivotPrice,\\n pivotOracleEnabled && pivotOracle != address(0)\\n );\\n if (mainPrice != INVALID_PRICE && validatedPivotMain) return mainPrice;\\n\\n // Compare fallback and pivot if main oracle comparision fails with pivot\\n // Return fallback price when fallback price is validated successfully with pivot oracle\\n (uint256 fallbackPrice, bool validatedPivotFallback) = _getFallbackOraclePrice(asset, pivotPrice);\\n if (fallbackPrice != INVALID_PRICE && validatedPivotFallback) return fallbackPrice;\\n\\n // Lastly compare main price and fallback price\\n if (\\n mainPrice != INVALID_PRICE &&\\n fallbackPrice != INVALID_PRICE &&\\n boundValidator.validatePriceWithAnchorPrice(asset, mainPrice, fallbackPrice)\\n ) {\\n return mainPrice;\\n }\\n\\n revert(\\\"invalid resilient oracle price\\\");\\n }\\n\\n /**\\n * @notice Gets a price for the provided asset\\n * @dev This function won't revert when price is 0, because the fallback oracle may still be\\n * able to fetch a correct price\\n * @param asset asset address\\n * @param pivotPrice Pivot oracle price\\n * @param pivotEnabled If pivot oracle is not empty and enabled\\n * @return price USD price in scaled decimals\\n * e.g. asset decimals is 8 then price is returned as 10**18 * 10**(18-8) = 10**28 decimals\\n * @return pivotValidated Boolean representing if the validation of main oracle price\\n * and pivot oracle price were successful\\n * @custom:error Invalid price error is thrown if main oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if main oracle is not enabled or main oracle\\n * address is null\\n */\\n function _getMainOraclePrice(\\n address asset,\\n uint256 pivotPrice,\\n bool pivotEnabled\\n ) internal view returns (uint256, bool) {\\n (address mainOracle, bool mainOracleEnabled) = getOracle(asset, OracleRole.MAIN);\\n if (mainOracleEnabled && mainOracle != address(0)) {\\n try OracleInterface(mainOracle).getPrice(asset) returns (uint256 mainOraclePrice) {\\n if (!pivotEnabled) {\\n return (mainOraclePrice, true);\\n }\\n if (pivotPrice == INVALID_PRICE) {\\n return (mainOraclePrice, false);\\n }\\n return (\\n mainOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, mainOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function won't revert when the price is 0 because getPrice checks if price is > 0\\n * @param asset asset address\\n * @return price USD price in 18 decimals\\n * @return pivotValidated Boolean representing if the validation of fallback oracle price\\n * and pivot oracle price were successfully\\n * @custom:error Invalid price error is thrown if fallback oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if fallback oracle is not enabled or fallback oracle\\n * address is null\\n */\\n function _getFallbackOraclePrice(address asset, uint256 pivotPrice) private view returns (uint256, bool) {\\n (address fallbackOracle, bool fallbackEnabled) = getOracle(asset, OracleRole.FALLBACK);\\n if (fallbackEnabled && fallbackOracle != address(0)) {\\n try OracleInterface(fallbackOracle).getPrice(asset) returns (uint256 fallbackOraclePrice) {\\n if (pivotPrice == INVALID_PRICE) {\\n return (fallbackOraclePrice, false);\\n }\\n return (\\n fallbackOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, fallbackOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function returns the underlying asset of a vToken\\n * @param vToken vToken address\\n * @return asset underlying asset address\\n */\\n function _getUnderlyingAsset(address vToken) private view notNullAddress(vToken) returns (address asset) {\\n if (vToken == nativeMarket) {\\n asset = NATIVE_TOKEN_ADDR;\\n } else if (vToken == vai) {\\n asset = vai;\\n } else {\\n asset = VBep20Interface(vToken).underlying();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xdaaa90daa8ca5bda477729aaa5d5ff3e5305635baec1799a368d564ae2a13c4c\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\ninterface OracleInterface {\\n function getPrice(address asset) external view returns (uint256);\\n}\\n\\ninterface ResilientOracleInterface is OracleInterface {\\n function updatePrice(address vToken) external;\\n\\n function updateAssetPrice(address asset) external;\\n\\n function getUnderlyingPrice(address vToken) external view returns (uint256);\\n}\\n\\ninterface TwapInterface is OracleInterface {\\n function updateTwap(address asset) external returns (uint256);\\n}\\n\\ninterface BoundValidatorInterface {\\n function validatePriceWithAnchorPrice(\\n address asset,\\n uint256 reporterPrice,\\n uint256 anchorPrice\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x2432799b0d824fc701beb4c30146e912b9aeecf77b5c1635dde6c5fbe6bfc3a7\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/VBep20Interface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\ninterface VBep20Interface is IERC20Metadata {\\n /**\\n * @notice Underlying asset for this VToken\\n */\\n function underlying() external view returns (address);\\n}\\n\",\"keccak256\":\"0x6e71c3df86501df5c0e4bace1333c0c91f9f9cced252a54fb99eeda219b789d5\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/constants.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\n/// @dev Base unit for computations, usually used in scaling (multiplications, divisions)\\nuint256 constant EXP_SCALE = 1e18;\\n\\n/// @dev A unit (literal one) in EXP_SCALE, usually used in additions/subtractions\\nuint256 constant MANTISSA_ONE = EXP_SCALE;\\n\\n/// @dev The approximate number of seconds per year\\nuint256 constant SECONDS_PER_YEAR = 31_536_000;\\n\",\"keccak256\":\"0x14de93ead464da249af31bea0e3bcfb62ec693bea3475fb4d90f055ac81dc5eb\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/validators.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\n/// @notice Thrown if the supplied address is a zero address where it is not allowed\\nerror ZeroAddressNotAllowed();\\n\\n/// @notice Thrown if the supplied value is 0 where it is not allowed\\nerror ZeroValueNotAllowed();\\n\\n/// @notice Checks if the provided address is nonzero, reverts otherwise\\n/// @param address_ Address to check\\n/// @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address\\nfunction ensureNonzeroAddress(address address_) pure {\\n if (address_ == address(0)) {\\n revert ZeroAddressNotAllowed();\\n }\\n}\\n\\n/// @notice Checks if the provided value is nonzero, reverts otherwise\\n/// @param value_ Value to check\\n/// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\nfunction ensureNonzeroValue(uint256 value_) pure {\\n if (value_ == 0) {\\n revert ZeroValueNotAllowed();\\n }\\n}\\n\",\"keccak256\":\"0xdb88e14d50dd21889ca3329d755673d022c47e8da005b6a545c7f69c2c4b7b86\",\"license\":\"BSD-3-Clause\"},\"contracts/Interfaces/IConverterNetwork.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { IAbstractTokenConverter } from \\\"../TokenConverter/IAbstractTokenConverter.sol\\\";\\n\\n/**\\n * @title IConverterNetwork\\n * @author Venus\\n * @notice Interface implemented by `ConverterNetwork`.\\n */\\ninterface IConverterNetwork {\\n /// @notice Adds new converter to the array\\n /// @param _tokenConverter Address of the token converter\\n function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Removes converter from the array\\n /// @param _tokenConverter Address of the token converter\\n function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice This function returns the array containing all the converters addresses\\n /// @return Array containing all the converters addresses\\n function getAllConverters() external view returns (IAbstractTokenConverter[] memory);\\n\\n /// @notice This function checks for given address is converter or not\\n /// @param _tokenConverter Address of the token converter\\n /// @return boolean true if given address is converter otherwise false\\n function isTokenConverter(address _tokenConverter) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xd9a747f176d9b9de220331b87ed711cc2bd594a118b538a35f3c47060bff7a8b\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/AbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { ReentrancyGuardUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { AccessControlledV8 } from \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress, ensureNonzeroValue } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\nimport { MANTISSA_ONE, EXP_SCALE } from \\\"@venusprotocol/solidity-utilities/contracts/constants.sol\\\";\\n\\nimport { IAbstractTokenConverter } from \\\"./IAbstractTokenConverter.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @title AbstractTokenConverter\\n/// @author Venus\\n/// @notice Abstract contract will be extended by SingleTokenConverter and RiskFundConverter\\n/*\\n * This contract specifies four functions for converting tokens, each applicable under following circumstances:\\n *\\n * Case I: TokenIn -> deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions supporting fees can only be utilized to convert tokens which are:\\n * a. convertExactTokensSupportingFeeOnTransferTokens\\n * b. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case II: TokenIn -> deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions supporting fee can only be utilized to convert tokens which are:\\n * similar to Case I.\\n *\\n * Case III: TokenIn -> non-deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * a. convertExactTokens\\n * b. convertForExactTokens\\n * c. convertExactTokensSupportingFeeOnTransferTokens\\n * d. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case IV: TokenIn -> non-deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * similar to Case III.\\n *\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n * Example 1:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInAmount - 100\\n * tokenOutMinAmount - minimum amount desired by the user(let's say 70)\\n * Here user can use `convertExactTokens` or `convertExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertExactTokens` is used).\\n * Now first tokenInAddress tokens will be transferred from the user to the contract, on the basis of amount\\n * received(as tokenInAddress can be deflationary token) tokenAmountOut will be calculated and will be transferred\\n * to the user and if amount sent is less than tokenOutMinAmount, tx will revert. If amount sent is satisfied(let's say\\n * 80 or even 70) then at last the actual amount received and the amount that was supposed to be received by the contract will\\n * be compared, if they differ then the whole tx will revert as user was supposed to use `convertExactTokensSupportingFeeOnTransferTokens`\\n * function for tokenIn as deflationary token.\\n *\\n * Example 2:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInMaxAmount - maximum amount user is willing to provide(let's say 100)\\n * tokenOutAmount - 70\\n * Here user can use `convertForExactTokens` or `convertForExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertForExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertForExactTokens` is used),\\n * which on the basis of tokenOutAmount provided will calculate tokenInAmount based on the tokens prices and will transfer\\n * tokens from the user to the contract, now the actual amount received(as tokenInAddress can be deflationary token) will be\\n * compared with tokenInMaxAmount if it is greater, tx will revert. If In amount is satisfied(let's say 90 or even 100) then\\n * new tokenOutAmount will be calculated, and tokenOutAddress tokens will be transferred to the user, but at last the\\n * old tokenOutAmount and new tokenOutAmount will be compared and if they differ whole tx will revert, because user was\\n * supposed to use `convertForExactTokensSupportingFeeOnTransferTokens` function for tokenIn as deflationary token.\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n *\\n * This contract also supports private conversion between the converters:\\n * Private conversions:\\n * Private conversions is designed in order to convert the maximum amount of tokens received from PSR(to any converter) between\\n * existing converters to save incentive and lower the dependency of users for conversion. So Private Conversion will be executed\\n * by converters on it's own whenever funds are received from PSR. No incentive will be offered during private conversion.\\n *\\n * It will execute on updateAssetsState() function call in Converter Contracts. After this function call, converter will first\\n * check for the amount received. If base asset is received then it will be directly sent to the destination address and no private\\n * conversion will happen otherwise converter will interact with ConverterNetwork contract to find other valid converters who are providing the conversion for:\\n *\\n * tokenAddressIn: As asset received by that converter on updateAssetsState() function call.\\n * tokenAddressOut: As base asset of that converter.\\n *\\n * ConverterNetwork:\\n * This contract will contain all the converters, and will provide valid converters which can perform the execution according to tokenAddressIn\\n * and tokenAddressOut provided.\\n *\\n * findTokenConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for users).\\n *\\n * findTokenConvertersForConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for converters).\\n */\\n\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\nabstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenConverter, ReentrancyGuardUpgradeable {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Maximum incentive could be\\n uint256 public constant MAX_INCENTIVE = 0.5e18;\\n\\n /// @notice Min amount to convert for private conversions. Defined in USD, with 18 decimals\\n uint256 public minAmountToConvert;\\n\\n /// @notice Venus price oracle contract\\n ResilientOracle public priceOracle;\\n\\n /// @notice conversion configurations for the existing pairs\\n /// @dev tokenAddressIn => tokenAddressOut => ConversionConfig\\n mapping(address => mapping(address => ConversionConfig)) public conversionConfigurations;\\n\\n /// @notice Address that all incoming tokens are transferred to\\n address public destinationAddress;\\n\\n /// @notice Boolean for if conversion is paused\\n bool public conversionPaused;\\n\\n /// @notice Address of the converterNetwork contract\\n IConverterNetwork public converterNetwork;\\n\\n /// @dev This empty reserved space is put in place to allow future versions to add new\\n /// variables without shifting down storage in the inheritance chain.\\n /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n uint256[45] private __gap;\\n\\n /// @notice Emitted when config is updated for tokens pair\\n event ConversionConfigUpdated(\\n address indexed tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 oldIncentive,\\n uint256 newIncentive,\\n ConversionAccessibility oldAccess,\\n ConversionAccessibility newAccess\\n );\\n /// @notice Emitted when price oracle address is updated\\n event PriceOracleUpdated(ResilientOracle indexed oldPriceOracle, ResilientOracle indexed priceOracle);\\n\\n /// @notice Emitted when destination address is updated\\n event DestinationAddressUpdated(address indexed oldDestinationAddress, address indexed destinationAddress);\\n\\n /// @notice Emitted when converterNetwork address is updated\\n event ConverterNetworkAddressUpdated(address indexed oldConverterNetwork, address indexed converterNetwork);\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens\\n event ConvertedExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens\\n event ConvertedForExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\\n event ConvertedExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\\n event ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when conversion is paused\\n event ConversionPaused(address indexed sender);\\n\\n /// @notice Emitted when conversion is unpaused\\n event ConversionResumed(address indexed sender);\\n\\n /// @notice Event emitted when tokens are swept\\n event SweepToken(address indexed token, address indexed to, uint256 amount);\\n\\n /// @notice Emitted when minimum amount to convert is updated\\n event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);\\n\\n /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\\n error AmountOutMismatched();\\n\\n /// @notice Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\\n error AmountInMismatched();\\n\\n /// @notice Thrown when given input amount is zero\\n error InsufficientInputAmount();\\n\\n /// @notice Thrown when given output amount is zero\\n error InsufficientOutputAmount();\\n\\n /// @notice Thrown when conversion is disabled or config does not exist for given pair\\n error ConversionConfigNotEnabled();\\n\\n /// @notice Thrown when conversion is enabled only for private conversions\\n error ConversionEnabledOnlyForPrivateConversions();\\n\\n /// @notice Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n error InvalidToAddress();\\n\\n /// @notice Thrown when incentive is higher than the MAX_INCENTIVE\\n error IncentiveTooHigh(uint256 incentive, uint256 maxIncentive);\\n\\n /// @notice Thrown when amountOut is lower than amountOutMin\\n error AmountOutLowerThanMinRequired(uint256 amountOutMantissa, uint256 amountOutMinMantissa);\\n\\n /// @notice Thrown when amountIn is higher than amountInMax\\n error AmountInHigherThanMax(uint256 amountInMantissa, uint256 amountInMaxMantissa);\\n\\n /// @notice Thrown when conversion is paused\\n error ConversionTokensPaused();\\n\\n /// @notice Thrown when conversion is Active\\n error ConversionTokensActive();\\n\\n /// @notice Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\\n error InvalidTokenConfigAddresses();\\n\\n /// @notice Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\\n error InsufficientPoolLiquidity();\\n\\n /// @notice When address of the ConverterNetwork is not set or Zero address\\n error InvalidConverterNetwork();\\n\\n /// @notice Thrown when trying to set non zero incentive for private conversion\\n error NonZeroIncentiveForPrivateConversion();\\n\\n /// @notice Thrown when using convertForExactTokens deflationary tokens\\n error DeflationaryTokenNotSupported();\\n\\n /// @notice Thrown when minimum amount to convert is zero\\n error InvalidMinimumAmountToConvert();\\n\\n /// @notice Thrown when there is a mismatch in the length of input arrays\\n error InputLengthMisMatch();\\n\\n /**\\n * @notice Modifier to ensure valid conversion parameters for a token conversion\\n * and check if conversion is paused or not\\n * @param to The recipient address for the converted tokens\\n * @param tokenAddressIn The input token address for the conversion\\n * @param tokenAddressOut The output token address for the conversion\\n */\\n modifier validConversionParameters(\\n address to,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) {\\n _checkConversionPaused();\\n ensureNonzeroAddress(to);\\n if (to == tokenAddressIn || to == tokenAddressOut) {\\n revert InvalidToAddress();\\n }\\n _;\\n }\\n\\n /// @notice Pause conversion of tokens\\n /// @custom:event Emits ConversionPaused on success\\n /// @custom:error ConversionTokensPaused thrown when conversion is already paused\\n /// @custom:access Restricted by ACM\\n function pauseConversion() external {\\n _checkAccessAllowed(\\\"pauseConversion()\\\");\\n _checkConversionPaused();\\n conversionPaused = true;\\n emit ConversionPaused(msg.sender);\\n }\\n\\n /// @notice Resume conversion of tokens.\\n /// @custom:event Emits ConversionResumed on success\\n /// @custom:error ConversionTokensActive thrown when conversion is already active\\n /// @custom:access Restricted by ACM\\n function resumeConversion() external {\\n _checkAccessAllowed(\\\"resumeConversion()\\\");\\n if (!conversionPaused) {\\n revert ConversionTokensActive();\\n }\\n\\n conversionPaused = false;\\n emit ConversionResumed(msg.sender);\\n }\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:access Only Governance\\n function setPriceOracle(ResilientOracle priceOracle_) external onlyOwner {\\n _setPriceOracle(priceOracle_);\\n }\\n\\n /// @notice Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:access Only Governance\\n function setDestination(address destinationAddress_) external onlyOwner {\\n _setDestination(destinationAddress_);\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:access Only Governance\\n function setConverterNetwork(IConverterNetwork converterNetwork_) external onlyOwner {\\n _setConverterNetwork(converterNetwork_);\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:access Only Governance\\n function setMinAmountToConvert(uint256 minAmountToConvert_) external {\\n _checkAccessAllowed(\\\"setMinAmountToConvert(uint256)\\\");\\n _setMinAmountToConvert(minAmountToConvert_);\\n }\\n\\n /// @notice Batch sets the conversion configurations\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressesOut Array of addresses of tokenOut\\n /// @param conversionConfigs Array of conversionConfig config details to update\\n /// @custom:error InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\\n function setConversionConfigs(\\n address tokenAddressIn,\\n address[] calldata tokenAddressesOut,\\n ConversionConfig[] calldata conversionConfigs\\n ) external {\\n uint256 tokenOutArrayLength = tokenAddressesOut.length;\\n if (tokenOutArrayLength != conversionConfigs.length) revert InputLengthMisMatch();\\n\\n for (uint256 i; i < tokenOutArrayLength; ) {\\n setConversionConfig(tokenAddressIn, tokenAddressesOut[i], conversionConfigs[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n /// @custom:error AmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert AmountInMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract,\\n /// otherwise the amount is adjusted\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n /// @custom:error AmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountOut != amountOutMantissa) {\\n revert AmountOutMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of\\n /// tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted.\\n /// The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokensSupportingFeeOnTransferTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice To sweep ERC20 tokens and transfer them to user(to address)\\n /// @param tokenAddress The address of the ERC-20 token to sweep\\n /// @param to The address to which tokens will be transferred\\n /// @param amount The amount to transfer\\n /// @custom:event Emits SweepToken event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\\n /// @custom:access Only Governance\\n function sweepToken(\\n address tokenAddress,\\n address to,\\n uint256 amount\\n ) external onlyOwner nonReentrant {\\n ensureNonzeroAddress(tokenAddress);\\n ensureNonzeroAddress(to);\\n ensureNonzeroValue(amount);\\n\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n preSweepToken(tokenAddress, amount);\\n token.safeTransfer(to, amount);\\n\\n emit SweepToken(tokenAddress, to, amount);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @notice The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n amountConvertedMantissa = amountInMantissa;\\n uint256 tokenInToOutConversion;\\n (amountOutMantissa, tokenInToOutConversion) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountConvertedMantissa = _divRoundingUp(maxTokenOutReserve * EXP_SCALE, tokenInToOutConversion);\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n\\n amountConvertedMantissa = amountOutMantissa;\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountOutMantissa, ) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountInMantissa;\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountOutMantissa;\\n }\\n\\n /// @notice This method updated the states of this contract after getting funds from PSR\\n /// after settling the amount(if any) through privateConversion between converters\\n /// @dev This function is called by protocolShareReserve\\n /// @dev call _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then\\n /// it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n function updateAssetsState(address comptroller, address asset) public nonReentrant {\\n uint256 balanceDiff = _updateAssetsState(comptroller, asset);\\n if (balanceDiff > 0) {\\n _privateConversion(comptroller, asset, balanceDiff);\\n }\\n }\\n\\n /// @notice Set the configuration for new or existing conversion pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n /// @custom:event Emits ConversionConfigUpdated event on success\\n /// @custom:error Unauthorized error is thrown when the call is not authorized by AccessControlManager\\n /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero\\n /// @custom:error NonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\\n /// @custom:access Controlled by AccessControlManager\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) public {\\n _checkAccessAllowed(\\\"setConversionConfig(address,address,ConversionConfig)\\\");\\n ensureNonzeroAddress(tokenAddressIn);\\n ensureNonzeroAddress(tokenAddressOut);\\n\\n if (conversionConfig.incentive > MAX_INCENTIVE) {\\n revert IncentiveTooHigh(conversionConfig.incentive, MAX_INCENTIVE);\\n }\\n\\n if (\\n (tokenAddressIn == tokenAddressOut) ||\\n (tokenAddressIn != _getDestinationBaseAsset()) ||\\n conversionConfigurations[tokenAddressOut][tokenAddressIn].conversionAccess != ConversionAccessibility.NONE\\n ) {\\n revert InvalidTokenConfigAddresses();\\n }\\n\\n if (\\n (conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) &&\\n conversionConfig.incentive != 0\\n ) {\\n revert NonZeroIncentiveForPrivateConversion();\\n }\\n\\n if (\\n ((conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) ||\\n (conversionConfig.conversionAccess == ConversionAccessibility.ALL)) &&\\n (address(converterNetwork) == address(0))\\n ) {\\n revert InvalidConverterNetwork();\\n }\\n\\n ConversionConfig storage configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n emit ConversionConfigUpdated(\\n tokenAddressIn,\\n tokenAddressOut,\\n configuration.incentive,\\n conversionConfig.incentive,\\n configuration.conversionAccess,\\n conversionConfig.conversionAccess\\n );\\n\\n if (conversionConfig.conversionAccess == ConversionAccessibility.NONE) {\\n delete conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n } else {\\n configuration.incentive = conversionConfig.incentive;\\n configuration.conversionAccess = conversionConfig.conversionAccess;\\n }\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) public view virtual returns (uint256 tokenBalance);\\n\\n /// @dev Operations to perform before sweeping tokens\\n /// @param token Address of the token\\n /// @param amount Amount transferred to address(to)\\n function preSweepToken(address token, uint256 amount) internal virtual {}\\n\\n /// @dev Converts exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return amountOutMantissa Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function _convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 amountOutMantissa) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, amountOutMantissa) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n if (amountOutMantissa < amountOutMinMantissa) {\\n revert AmountOutLowerThanMinRequired(amountOutMantissa, amountOutMinMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for exact amount of tokenAddressOut used for non deflationry tokens\\n /// it is called by convertForExactTokens function\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error DeflationaryTokenNotSupported is thrown if tokenAddressIn is deflationary token\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert DeflationaryTokenNotSupported();\\n }\\n\\n if (actualAmountIn > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n actualAmountOut = amountOutMantissa;\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for the amount of tokenAddressOut used for deflationary tokens\\n /// it is called by convertForExactTokensSupportingFeeOnTransferTokens function\\n /// @notice Advising users to input a smaller amountOutMantissa to avoid potential transaction revert\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n if (amountInMantissa > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, actualAmountOut) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n _doTransferOut(tokenAddressOut, to, actualAmountOut);\\n }\\n\\n /// @dev return actualAmountOut from reserves for tokenAddressOut\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred\\n /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n function _doTransferOut(\\n address tokenAddressOut,\\n address to,\\n uint256 amountConvertedMantissa\\n ) internal {\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountConvertedMantissa) {\\n revert InsufficientPoolLiquidity();\\n }\\n\\n _preTransferHook(tokenAddressOut, amountConvertedMantissa);\\n\\n IERC20Upgradeable tokenOut = IERC20Upgradeable(tokenAddressOut);\\n tokenOut.safeTransfer(to, amountConvertedMantissa);\\n }\\n\\n /// @notice Transfer tokenAddressIn from user to destination\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @return actualAmountIn Actual amount transferred to destination\\n function _doTransferIn(address tokenAddressIn, uint256 amountInMantissa) internal returns (uint256 actualAmountIn) {\\n IERC20Upgradeable tokenIn = IERC20Upgradeable(tokenAddressIn);\\n uint256 balanceBeforeDestination = tokenIn.balanceOf(destinationAddress);\\n tokenIn.safeTransferFrom(msg.sender, destinationAddress, amountInMantissa);\\n uint256 balanceAfterDestination = tokenIn.balanceOf(destinationAddress);\\n actualAmountIn = balanceAfterDestination - balanceBeforeDestination;\\n }\\n\\n /// @dev Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:event Emits PriceOracleUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero\\n function _setPriceOracle(ResilientOracle priceOracle_) internal {\\n ensureNonzeroAddress(address(priceOracle_));\\n emit PriceOracleUpdated(priceOracle, priceOracle_);\\n priceOracle = priceOracle_;\\n }\\n\\n /// @dev Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:event Emits DestinationAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when destination address is zero\\n function _setDestination(address destinationAddress_) internal {\\n ensureNonzeroAddress(destinationAddress_);\\n emit DestinationAddressUpdated(destinationAddress, destinationAddress_);\\n destinationAddress = destinationAddress_;\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:event Emits ConverterNetworkAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n function _setConverterNetwork(IConverterNetwork converterNetwork_) internal {\\n ensureNonzeroAddress(address(converterNetwork_));\\n emit ConverterNetworkAddressUpdated(address(converterNetwork), address(converterNetwork_));\\n converterNetwork = converterNetwork_;\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:event MinAmountToConvertUpdated is emitted in success\\n /// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\n function _setMinAmountToConvert(uint256 minAmountToConvert_) internal {\\n ensureNonzeroValue(minAmountToConvert_);\\n emit MinAmountToConvertUpdated(minAmountToConvert, minAmountToConvert_);\\n minAmountToConvert = minAmountToConvert_;\\n }\\n\\n /// @dev Hook to perform after converting tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param amountIn Amount of tokenIn converted\\n /// @param amountOut Amount of tokenOut converted\\n function _postConversionHook(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n ) internal virtual {}\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n __AccessControlled_init(accessControlManager_);\\n __ReentrancyGuard_init();\\n __AbstractTokenConverter_init_unchained(priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init_unchained(\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n _setPriceOracle(priceOracle_);\\n _setDestination(destinationAddress_);\\n _setMinAmountToConvert(minAmountToConvert_);\\n conversionPaused = false;\\n }\\n\\n /// @dev _updateAssetsState hook to update the states of reserves transferred for the specific comptroller\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n /// @return Amount of asset, for _privateConversion\\n function _updateAssetsState(address comptroller, address asset) internal virtual returns (uint256) {}\\n\\n /// @dev This method is used to convert asset into base asset by converting them with other converters which supports the pair and transfer the funds to\\n /// destination contract as destination's base asset\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset\\n /// @param amountToConvert Amount of the tokenAddressOut transferred to converter\\n function _privateConversion(\\n address comptroller,\\n address tokenAddressOut,\\n uint256 amountToConvert\\n ) internal {\\n address tokenAddressIn = _getDestinationBaseAsset();\\n address _destinationAddress = destinationAddress;\\n uint256 convertedTokenInBalance;\\n if (address(converterNetwork) != address(0)) {\\n (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork\\n .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn);\\n uint256 convertersLength = converterAddresses.length;\\n for (uint256 i; i < convertersLength; ) {\\n if (converterBalances[i] == 0) break;\\n (, uint256 amountIn) = IAbstractTokenConverter(converterAddresses[i]).getUpdatedAmountIn(\\n converterBalances[i],\\n tokenAddressOut,\\n tokenAddressIn\\n );\\n if (amountIn > amountToConvert) {\\n amountIn = amountToConvert;\\n }\\n\\n if (!_validateMinAmountToConvert(amountIn, tokenAddressOut)) {\\n break;\\n }\\n\\n uint256 balanceBefore = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n\\n IERC20Upgradeable(tokenAddressOut).forceApprove(converterAddresses[i], amountIn);\\n IAbstractTokenConverter(converterAddresses[i]).convertExactTokens(\\n amountIn,\\n 0,\\n tokenAddressOut,\\n tokenAddressIn,\\n _destinationAddress\\n );\\n\\n uint256 balanceAfter = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n amountToConvert -= amountIn;\\n convertedTokenInBalance += (balanceAfter - balanceBefore);\\n\\n if (amountToConvert == 0) break;\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n _postPrivateConversionHook(\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance,\\n tokenAddressOut,\\n amountToConvert\\n );\\n }\\n\\n /// @dev This hook is used to update states for the converter after the privateConversion\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressIn Address of the destination's base asset\\n /// @param convertedTokenInBalance Amount of the base asset received after the conversion\\n /// @param tokenAddressOut Address of the asset transferred to other converter in exchange of base asset\\n /// @param convertedTokenOutBalance Amount of tokenAddressOut transferred from this converter\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address tokenAddressOut,\\n uint256 convertedTokenOutBalance\\n ) internal virtual {}\\n\\n /// @notice This hook is used to update the state for asset reserves before transferring tokenOut to user\\n /// @param tokenOutAddress Address of the asset to be transferred to the user\\n /// @param amountOut Amount of tokenAddressOut transferred from this converter\\n function _preTransferHook(address tokenOutAddress, uint256 amountOut) internal virtual {}\\n\\n /// @dev Checks if amount to convert is greater than minimum amount to convert or not\\n /// @param amountIn The amount to convert\\n /// @param tokenAddress Address of the token\\n /// @return isValid true if amount to convert is greater than minimum amount to convert\\n function _validateMinAmountToConvert(uint256 amountIn, address tokenAddress) internal returns (bool isValid) {\\n priceOracle.updateAssetPrice(tokenAddress);\\n uint256 amountInInUsd = (priceOracle.getPrice(tokenAddress) * amountIn) / EXP_SCALE;\\n\\n if (amountInInUsd >= minAmountToConvert) {\\n isValid = true;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountOutMantissa, uint256 tokenInToOutConversion) {\\n if (amountInMantissa == 0) {\\n revert InsufficientInputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n if (address(converterNetwork) != address(0) && (converterNetwork.isTokenConverter(msg.sender))) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n /// amount of tokenAddressOut after including incentive as amountOutMantissa will be greater than actual as it gets\\n /// multiplied by conversionWithIncentive which will be >= 1\\n amountOutMantissa = (amountInMantissa * tokenInToOutConversion) / (EXP_SCALE);\\n }\\n\\n /// @dev To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @dev For user conversions, the function returns an amountInMantissa that is rounded up, ensuring that the equivalent amountInMantissa\\n /// is obtained from users for corresponding amountOutMantissa, preventing any losses to the protocol. However, no rounding up is required for private conversions\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountInMantissa, uint256 tokenInToOutConversion) {\\n if (amountOutMantissa == 0) {\\n revert InsufficientOutputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n\\n bool isPrivateConversion = address(converterNetwork) != address(0) &&\\n converterNetwork.isTokenConverter(msg.sender);\\n if (isPrivateConversion) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n /// amount of tokenAddressIn after considering incentive(i.e. amountInMantissa will be less than actual amountInMantissa if incentive > 0)\\n if (isPrivateConversion) {\\n amountInMantissa =\\n (amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE) /\\n (tokenInUnderlyingPrice * conversionWithIncentive);\\n } else {\\n amountInMantissa = _divRoundingUp(\\n amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE,\\n tokenInUnderlyingPrice * conversionWithIncentive\\n );\\n }\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n }\\n\\n /// @dev Check if msg.sender is allowed to convert as per onlyForPrivateConversions flag\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function _checkPrivateConversion(address tokenAddressIn, address tokenAddressOut) internal view {\\n bool isConverter = (address(converterNetwork) != address(0)) && converterNetwork.isTokenConverter(msg.sender);\\n if (\\n (!(isConverter) &&\\n (conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS))\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n }\\n\\n /// @dev To check, is conversion paused\\n /// @custom:error ConversionTokensPaused is thrown when token conversion is paused\\n function _checkConversionPaused() internal view {\\n if (conversionPaused) {\\n revert ConversionTokensPaused();\\n }\\n }\\n\\n /// @dev Get base asset address of the destination contract\\n /// @return Address of the base asset\\n function _getDestinationBaseAsset() internal view virtual returns (address) {}\\n\\n /// @dev Performs division where the result is rounded up\\n /// @param numerator The numerator of the division operation\\n /// @param denominator The denominator of the division operation. Must be non-zero\\n /// @return The result of the division, rounded up\\n function _divRoundingUp(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\\n return (numerator + denominator - 1) / denominator;\\n }\\n}\\n\",\"keccak256\":\"0xf87680dcb5a46a16663923c575661eda78ef57d29b7d78a85ddac00062426e18\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/IAbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @notice Interface for AbstractTokenConverter\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ninterface IAbstractTokenConverter {\\n /// @notice This enum define the all possible ways of conversion can happen\\n enum ConversionAccessibility {\\n NONE, // Conversion is disable for the pair\\n ALL, // Conversion is enable for private conversion and users\\n ONLY_FOR_CONVERTERS, // Conversion is enable only for private conversion\\n ONLY_FOR_USERS // Conversion is enable only for users\\n }\\n\\n /// @notice This struct represents the configuration for a token conversion.\\n struct ConversionConfig {\\n /// incentive on conversion of tokens in mantissa i.e 10% incentive would be 0.1 * 1e18\\n uint256 incentive;\\n /// enable or disable conversion for users or converters or both or none\\n ConversionAccessibility conversionAccess;\\n }\\n\\n /// @notice Pause conversion of tokens\\n function pauseConversion() external;\\n\\n /// @notice Resume conversion of tokens.\\n function resumeConversion() external;\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n function setPriceOracle(ResilientOracle priceOracle_) external;\\n\\n /// @notice Set the configuration for new or existing convert pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) external;\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Get the configuration for the pair of the tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return incentives Percentage of incentives to be distributed for the pair of tokens\\n /// @return conversionAccess Accessibility for the pair of tokens\\n function conversionConfigurations(address tokenAddressIn, address tokenAddressOut)\\n external\\n returns (uint256 incentives, ConversionAccessibility conversionAccess);\\n\\n /// @notice Get the address of the converterNetwork\\n function converterNetwork() external returns (IConverterNetwork converterNetwork);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) external view returns (uint256 tokenBalance);\\n}\\n\",\"keccak256\":\"0x7852d4f8a6dd1c80d14342f8ff2e26f723eb00c888e9a9e50a5fe8f95c59200c\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/SingleTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\n\\nimport { AbstractTokenConverter } from \\\"./AbstractTokenConverter.sol\\\";\\n\\n/// @title SingleTokenConverter\\n/// @author Venus\\n/// @notice SingleTokenConverter used for token conversions and sends received tokens\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ncontract SingleTokenConverter is AbstractTokenConverter {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Address of the base asset token\\n address public baseAsset;\\n\\n /// @notice The mapping contains the assets which are sent to destination directly\\n /// @dev Asset -> bool(should transfer directly on true)\\n mapping(address => bool) public assetsDirectTransfer;\\n\\n /// @notice Emitted when base asset is updated\\n event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset);\\n\\n /// @notice Emmitted after the funds transferred to the destination address\\n event AssetTransferredToDestination(\\n address indexed receiver,\\n address indexed comptroller,\\n address indexed asset,\\n uint256 amount\\n );\\n\\n /// @notice Emitted after the assetsDirectTransfer mapping is updated\\n event AssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value);\\n\\n /// @notice Thrown when the base asset is the same as the new base asset\\n error SameBaseAssetNotAllowed();\\n\\n /// @notice Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection\\n error DirectTransferBaseAssetNotAllowed();\\n\\n /// @notice Thrown when the `assetsDirectTransfer[asset]` is already `value`\\n /// @param asset The asset address whose `assetDirectTransfer` value went to be set\\n /// @param value The value to be set\\n error SameAssetDirectTransferNotAllowed(address asset, bool value);\\n\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor() {\\n // Note that the contract is upgradeable. Use initialize() or reinitializers\\n // to set the state variables.\\n _disableInitializers();\\n }\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param baseAsset_ Address of the base asset\\n /// @param minAmountToConvert_ Minimum amount to convert\\n function initialize(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n address baseAsset_,\\n uint256 minAmountToConvert_\\n ) public initializer {\\n _setBaseAsset(baseAsset_);\\n\\n // Initialize AbstractTokenConverter\\n __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @notice Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\\n /// @custom:event BaseAssetUpdated is emitted on success\\n /// @custom:access Only Governance\\n function setBaseAsset(address baseAsset_) external onlyOwner {\\n _setBaseAsset(baseAsset_);\\n }\\n\\n /// @notice Update the assetsDirectTransfer mapping\\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\\n /// @custom:event AssetsDirectTransferUpdated emits on success\\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\\n /// @custom:access Restricted by ACM\\n function setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) external virtual {\\n _checkAccessAllowed(\\\"setAssetsDirectTransfer(address[],bool[])\\\");\\n _setAssetsDirectTransfer(assets, values);\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param tokenAddress Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n tokenBalance = token.balanceOf(address(this));\\n }\\n\\n /// @dev It returns the balance of the `asset` in this contract. If `asset` is the `baseAsset`\\n /// or `assetsDirectTransfer[asset]` is true, then the balance of `asset` in this contract will\\n /// be transferred to the `destinationAddress` and 0 will be returned\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address.\\n /// @return balanceLeft Amount of asset, for _privateConversion\\n function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) {\\n IERC20Upgradeable token = IERC20Upgradeable(asset);\\n uint256 balance = token.balanceOf(address(this));\\n balanceLeft = balance;\\n\\n if (asset == baseAsset || assetsDirectTransfer[asset]) {\\n balanceLeft = 0;\\n token.safeTransfer(destinationAddress, balance);\\n emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance);\\n }\\n }\\n\\n /// @notice Hook called after a private conversion is completed\\n /// @dev Emits an AssetTransferredToDestination event if Private Conversion happens\\n /// @param comptroller The address of the comptroller (pool) associated with the conversion\\n /// @param tokenAddressIn The address of the input token that was converted\\n /// @param convertedTokenInBalance The amount of input token that was converted\\n /// @custom:event AssetTransferredToDestination Emitted when convertedTokenInBalance > 0, indicating\\n /// the converted assets were transferred to the destination address\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address,\\n uint256\\n ) internal override {\\n if (convertedTokenInBalance > 0) {\\n emit AssetTransferredToDestination(\\n destinationAddress,\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance\\n );\\n }\\n }\\n\\n /// @dev Update the assetsDirectTransfer mapping for destinationAddress\\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\\n /// @custom:event AssetsDirectTransferUpdated emits on success\\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\\n /// @custom:error DirectTransferBaseAssetNotAllowed thrown when an asset in `assets` is the `baseAsset`\\n /// @custom:error SameAssetDirectTransferNotAllowed thrown when the value to set for an asset doesn't differs\\n /// from its current value\\n function _setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) internal {\\n uint256 assetsLength = assets.length;\\n\\n if (assetsLength != values.length) {\\n revert InputLengthMisMatch();\\n }\\n\\n for (uint256 i; i < assetsLength; ++i) {\\n if (assets[i] == baseAsset) {\\n revert DirectTransferBaseAssetNotAllowed();\\n }\\n\\n if (assetsDirectTransfer[assets[i]] == values[i]) {\\n revert SameAssetDirectTransferNotAllowed(assets[i], values[i]);\\n }\\n\\n assetsDirectTransfer[assets[i]] = values[i];\\n emit AssetsDirectTransferUpdated(destinationAddress, assets[i], values[i]);\\n }\\n }\\n\\n /// @dev Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\\n /// @custom:event BaseAssetUpdated is emitted on success\\n function _setBaseAsset(address baseAsset_) internal {\\n ensureNonzeroAddress(baseAsset_);\\n\\n if (baseAsset == baseAsset_) {\\n revert SameBaseAssetNotAllowed();\\n }\\n\\n emit BaseAssetUpdated(baseAsset, baseAsset_);\\n baseAsset = baseAsset_;\\n }\\n\\n /// @dev Get base asset address\\n /// @return destinationBaseAsset Address of the base asset(baseAsset)\\n function _getDestinationBaseAsset() internal view override returns (address destinationBaseAsset) {\\n destinationBaseAsset = baseAsset;\\n }\\n}\\n\",\"keccak256\":\"0x3358796675c9c556ce90143ed762f7f2ed3ce46a5faeaf3d99574b0ba134cfac\",\"license\":\"BSD-3-Clause\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", "devdoc": { "author": "Venus", "custom:security-contact": "https://github.com/VenusProtocol/protocol-reserve#discussion", + "errors": { + "SameAssetDirectTransferNotAllowed(address,bool)": [ + { + "params": { + "asset": "The asset address whose `assetDirectTransfer` value went to be set", + "value": "The value to be set" + } + } + ] + }, "events": { "Initialized(uint8)": { "details": "Triggered when the contract has been initialized or reinitialized." @@ -1586,8 +1684,19 @@ "accessControlManager_": "The new address of the AccessControlManager" } }, + "setAssetsDirectTransfer(address[],bool[])": { + "custom:access": "Restricted by ACM", + "custom:error": "InputLengthMisMatch thrown when assets and values array lengths don't match", + "custom:event": "AssetsDirectTransferUpdated emits on success", + "params": { + "assets": "Addresses of the assets need to be added or removed for direct transfer", + "values": "Boolean value to indicate whether direct transfer is allowed for each asset." + } + }, "setBaseAsset(address)": { "custom:access": "Only Governance", + "custom:error": "ZeroAddressNotAllowed is thrown when address is zeroSameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset", + "custom:event": "BaseAssetUpdated is emitted on success", "params": { "baseAsset_": "The new address of the base asset" } @@ -1655,6 +1764,11 @@ } } }, + "stateVariables": { + "assetsDirectTransfer": { + "details": "Asset -> bool(should transfer directly on true)" + } + }, "title": "SingleTokenConverter", "version": 1 }, @@ -1705,6 +1819,11 @@ "notice": "Thrown when using convertForExactTokens deflationary tokens" } ], + "DirectTransferBaseAssetNotAllowed()": [ + { + "notice": "Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection" + } + ], "IncentiveTooHigh(uint256,uint256)": [ { "notice": "Thrown when incentive is higher than the MAX_INCENTIVE" @@ -1755,6 +1874,16 @@ "notice": "Thrown when trying to set non zero incentive for private conversion" } ], + "SameAssetDirectTransferNotAllowed(address,bool)": [ + { + "notice": "Thrown when the `assetsDirectTransfer[asset]` is already `value`" + } + ], + "SameBaseAssetNotAllowed()": [ + { + "notice": "Thrown when the base asset is the same as the new base asset" + } + ], "Unauthorized(address,address,string)": [ { "notice": "Thrown when the action is prohibited by AccessControlManager" @@ -1775,6 +1904,9 @@ "AssetTransferredToDestination(address,address,address,uint256)": { "notice": "Emmitted after the funds transferred to the destination address" }, + "AssetsDirectTransferUpdated(address,address,bool)": { + "notice": "Emitted after the assetsDirectTransfer mapping is updated" + }, "BaseAssetUpdated(address,address)": { "notice": "Emitted when base asset is updated" }, @@ -1826,6 +1958,9 @@ "accessControlManager()": { "notice": "Returns the address of the access control manager contract" }, + "assetsDirectTransfer(address)": { + "notice": "The mapping contains the assets which are sent to destination directly" + }, "balanceOf(address)": { "notice": "Get the balance for specific token" }, @@ -1883,6 +2018,9 @@ "setAccessControlManager(address)": { "notice": "Sets the address of AccessControlManager" }, + "setAssetsDirectTransfer(address[],bool[])": { + "notice": "Update the assetsDirectTransfer mapping" + }, "setBaseAsset(address)": { "notice": "Sets the base asset for the contract" }, @@ -2067,6 +2205,14 @@ "offset": 0, "slot": "301", "type": "t_address" + }, + { + "astId": 5318, + "contract": "contracts/TokenConverter/SingleTokenConverter.sol:SingleTokenConverter", + "label": "assetsDirectTransfer", + "offset": 0, + "slot": "302", + "type": "t_mapping(t_address,t_bool)" } ], "types": { @@ -2118,6 +2264,13 @@ "label": "enum IAbstractTokenConverter.ConversionAccessibility", "numberOfBytes": "1" }, + "t_mapping(t_address,t_bool)": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => bool)", + "numberOfBytes": "32", + "value": "t_bool" + }, "t_mapping(t_address,t_mapping(t_address,t_struct(ConversionConfig)5108_storage))": { "encoding": "mapping", "key": "t_address", diff --git a/deployments/arbitrumone/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json b/deployments/arbitrumone/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json new file mode 100644 index 00000000..774cd037 --- /dev/null +++ b/deployments/arbitrumone/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json @@ -0,0 +1,103 @@ +{ + "language": "Solidity", + "sources": { + "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./OwnableUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\n function __Ownable2Step_init() internal onlyInitializing {\n __Ownable_init_unchained();\n }\n\n function __Ownable2Step_init_unchained() internal onlyInitializing {\n }\n address private _pendingOwner;\n\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Returns the address of the pending owner.\n */\n function pendingOwner() public view virtual returns (address) {\n return _pendingOwner;\n }\n\n /**\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual override onlyOwner {\n _pendingOwner = newOwner;\n emit OwnershipTransferStarted(owner(), newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual override {\n delete _pendingOwner;\n super._transferOwnership(newOwner);\n }\n\n /**\n * @dev The new owner accepts the ownership transfer.\n */\n function acceptOwnership() public virtual {\n address sender = _msgSender();\n require(pendingOwner() == sender, \"Ownable2Step: caller is not the new owner\");\n _transferOwnership(sender);\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n function __Ownable_init() internal onlyInitializing {\n __Ownable_init_unchained();\n }\n\n function __Ownable_init_unchained() internal onlyInitializing {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if the sender is not the owner.\n */\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby disabling any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n */\n uint8 private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint8 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts.\n *\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n * constructor.\n *\n * Emits an {Initialized} event.\n */\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n * are added through upgrades and that require initialization.\n *\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n * cannot be nested. If one is invoked in the context of another, execution will revert.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n *\n * WARNING: setting the version to 255 will prevent any future reinitialization.\n *\n * Emits an {Initialized} event.\n */\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n *\n * Emits an {Initialized} event the first time it is successfully executed.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized != type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n\n /**\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\n */\n function _getInitializedVersion() internal view returns (uint8) {\n return _initialized;\n }\n\n /**\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n */\n function _isInitializing() internal view returns (bool) {\n return _initializing;\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n /**\n * @dev Emitted when the pause is triggered by `account`.\n */\n event Paused(address account);\n\n /**\n * @dev Emitted when the pause is lifted by `account`.\n */\n event Unpaused(address account);\n\n bool private _paused;\n\n /**\n * @dev Initializes the contract in unpaused state.\n */\n function __Pausable_init() internal onlyInitializing {\n __Pausable_init_unchained();\n }\n\n function __Pausable_init_unchained() internal onlyInitializing {\n _paused = false;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is not paused.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n modifier whenNotPaused() {\n _requireNotPaused();\n _;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is paused.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n modifier whenPaused() {\n _requirePaused();\n _;\n }\n\n /**\n * @dev Returns true if the contract is paused, and false otherwise.\n */\n function paused() public view virtual returns (bool) {\n return _paused;\n }\n\n /**\n * @dev Throws if the contract is paused.\n */\n function _requireNotPaused() internal view virtual {\n require(!paused(), \"Pausable: paused\");\n }\n\n /**\n * @dev Throws if the contract is not paused.\n */\n function _requirePaused() internal view virtual {\n require(paused(), \"Pausable: not paused\");\n }\n\n /**\n * @dev Triggers stopped state.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n function _pause() internal virtual whenNotPaused {\n _paused = true;\n emit Paused(_msgSender());\n }\n\n /**\n * @dev Returns to normal state.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n function _unpause() internal virtual whenPaused {\n _paused = false;\n emit Unpaused(_msgSender());\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuardUpgradeable is Initializable {\n // Booleans are more expensive than uint256 or any type that takes up a full\n // word because each write operation emits an extra SLOAD to first read the\n // slot's contents, replace the bits taken up by the boolean, and then write\n // back. This is the compiler's defense against contract upgrades and\n // pointer aliasing, and it cannot be disabled.\n\n // The values being non-zero value makes deployment a bit more expensive,\n // but in exchange the refund on every call to nonReentrant will be lower in\n // amount. Since refunds are capped to a percentage of the total\n // transaction's gas, it is best to keep them low in cases like this one, to\n // increase the likelihood of the full refund coming into effect.\n uint256 private constant _NOT_ENTERED = 1;\n uint256 private constant _ENTERED = 2;\n\n uint256 private _status;\n\n function __ReentrancyGuard_init() internal onlyInitializing {\n __ReentrancyGuard_init_unchained();\n }\n\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\n _status = _NOT_ENTERED;\n }\n\n /**\n * @dev Prevents a contract from calling itself, directly or indirectly.\n * Calling a `nonReentrant` function from another `nonReentrant`\n * function is not supported. It is possible to prevent this from happening\n * by making the `nonReentrant` function external, and making it call a\n * `private` function that does the actual work.\n */\n modifier nonReentrant() {\n _nonReentrantBefore();\n _;\n _nonReentrantAfter();\n }\n\n function _nonReentrantBefore() private {\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\n require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n // Any calls to nonReentrant after this point will fail\n _status = _ENTERED;\n }\n\n function _nonReentrantAfter() private {\n // By storing the original value once again, a refund is triggered (see\n // https://eips.ethereum.org/EIPS/eip-2200)\n _status = _NOT_ENTERED;\n }\n\n /**\n * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n * `nonReentrant` function in the call stack.\n */\n function _reentrancyGuardEntered() internal view returns (bool) {\n return _status == _ENTERED;\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20PermitUpgradeable {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\nimport \"../extensions/IERC20PermitUpgradeable.sol\";\nimport \"../../../utils/AddressUpgradeable.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20Upgradeable {\n using AddressUpgradeable for address;\n\n /**\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n /**\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n */\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n require(\n (value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n /**\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n uint256 oldAllowance = token.allowance(address(this), spender);\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\n }\n\n /**\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\n }\n }\n\n /**\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n * to be set to zero before setting it to a non-zero value, such as USDT.\n */\n function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\n\n if (!_callOptionalReturnBool(token, approvalCall)) {\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\n _callOptionalReturn(token, approvalCall);\n }\n }\n\n /**\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\n * Revert on invalid signature.\n */\n function safePermit(\n IERC20PermitUpgradeable token,\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal {\n uint256 nonceBefore = token.nonces(owner);\n token.permit(owner, spender, value, deadline, v, r, s);\n uint256 nonceAfter = token.nonces(owner);\n require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n *\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n */\n function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n // and not revert is the subcall reverts.\n\n (bool success, bytes memory returndata) = address(token).call(data);\n return\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n *\n * Furthermore, `isContract` will also return true if the target contract within\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n * which only has an effect at the end of a transaction.\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n *\n * _Available since v4.8._\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n if (success) {\n if (returndata.length == 0) {\n // only check isContract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n require(isContract(target), \"Address: call to non-contract\");\n }\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason or using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n function __Context_init() internal onlyInitializing {\n }\n\n function __Context_init_unchained() internal onlyInitializing {\n }\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n" + }, + "@openzeppelin/contracts/access/IAccessControl.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {AccessControl-_setupRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) external view returns (bool);\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n */\n function renounceRole(bytes32 role, address account) external;\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/IERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n" + }, + "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\";\n\nimport \"./IAccessControlManagerV8.sol\";\n\n/**\n * @title AccessControlledV8\n * @author Venus\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.8.13)\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\n */\nabstract contract AccessControlledV8 is Initializable, Ownable2StepUpgradeable {\n /// @notice Access control manager contract\n IAccessControlManagerV8 private _accessControlManager;\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n\n /// @notice Emitted when access control manager contract address is changed\n event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\n\n /// @notice Thrown when the action is prohibited by AccessControlManager\n error Unauthorized(address sender, address calledContract, string methodSignature);\n\n function __AccessControlled_init(address accessControlManager_) internal onlyInitializing {\n __Ownable2Step_init();\n __AccessControlled_init_unchained(accessControlManager_);\n }\n\n function __AccessControlled_init_unchained(address accessControlManager_) internal onlyInitializing {\n _setAccessControlManager(accessControlManager_);\n }\n\n /**\n * @notice Sets the address of AccessControlManager\n * @dev Admin function to set address of AccessControlManager\n * @param accessControlManager_ The new address of the AccessControlManager\n * @custom:event Emits NewAccessControlManager event\n * @custom:access Only Governance\n */\n function setAccessControlManager(address accessControlManager_) external onlyOwner {\n _setAccessControlManager(accessControlManager_);\n }\n\n /**\n * @notice Returns the address of the access control manager contract\n */\n function accessControlManager() external view returns (IAccessControlManagerV8) {\n return _accessControlManager;\n }\n\n /**\n * @dev Internal function to set address of AccessControlManager\n * @param accessControlManager_ The new address of the AccessControlManager\n */\n function _setAccessControlManager(address accessControlManager_) internal {\n require(address(accessControlManager_) != address(0), \"invalid acess control manager address\");\n address oldAccessControlManager = address(_accessControlManager);\n _accessControlManager = IAccessControlManagerV8(accessControlManager_);\n emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\n }\n\n /**\n * @notice Reverts if the call is not allowed by AccessControlManager\n * @param signature Method signature\n */\n function _checkAccessAllowed(string memory signature) internal view {\n bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\n\n if (!isAllowedToCall) {\n revert Unauthorized(msg.sender, address(this), signature);\n }\n }\n}\n" + }, + "@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport \"@openzeppelin/contracts/access/IAccessControl.sol\";\n\n/**\n * @title IAccessControlManagerV8\n * @author Venus\n * @notice Interface implemented by the `AccessControlManagerV8` contract.\n */\ninterface IAccessControlManagerV8 is IAccessControl {\n function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\n\n function revokeCallPermission(\n address contractAddress,\n string calldata functionSig,\n address accountToRevoke\n ) external;\n\n function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\n\n function hasPermission(\n address account,\n address contractAddress,\n string calldata functionSig\n ) external view returns (bool);\n}\n" + }, + "@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\ninterface OracleInterface {\n function getPrice(address asset) external view returns (uint256);\n}\n\ninterface ResilientOracleInterface is OracleInterface {\n function updatePrice(address vToken) external;\n\n function updateAssetPrice(address asset) external;\n\n function getUnderlyingPrice(address vToken) external view returns (uint256);\n}\n\ninterface TwapInterface is OracleInterface {\n function updateTwap(address asset) external returns (uint256);\n}\n\ninterface BoundValidatorInterface {\n function validatePriceWithAnchorPrice(\n address asset,\n uint256 reporterPrice,\n uint256 anchorPrice\n ) external view returns (bool);\n}\n" + }, + "@venusprotocol/oracle/contracts/interfaces/VBep20Interface.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface VBep20Interface is IERC20Metadata {\n /**\n * @notice Underlying asset for this VToken\n */\n function underlying() external view returns (address);\n}\n" + }, + "@venusprotocol/oracle/contracts/ResilientOracle.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\n// SPDX-FileCopyrightText: 2022 Venus\npragma solidity 0.8.25;\n\nimport \"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\";\nimport \"./interfaces/VBep20Interface.sol\";\nimport \"./interfaces/OracleInterface.sol\";\nimport \"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\";\n\n/**\n * @title ResilientOracle\n * @author Venus\n * @notice The Resilient Oracle is the main contract that the protocol uses to fetch prices of assets.\n *\n * DeFi protocols are vulnerable to price oracle failures including oracle manipulation and incorrectly\n * reported prices. If only one oracle is used, this creates a single point of failure and opens a vector\n * for attacking the protocol.\n *\n * The Resilient Oracle uses multiple sources and fallback mechanisms to provide accurate prices and protect\n * the protocol from oracle attacks. Currently it includes integrations with Chainlink, Pyth, Binance Oracle\n * and TWAP (Time-Weighted Average Price) oracles. TWAP uses PancakeSwap as the on-chain price source.\n *\n * For every market (vToken) we configure the main, pivot and fallback oracles. The oracles are configured per\n * vToken's underlying asset address. The main oracle oracle is the most trustworthy price source, the pivot\n * oracle is used as a loose sanity checker and the fallback oracle is used as a backup price source.\n *\n * To validate prices returned from two oracles, we use an upper and lower bound ratio that is set for every\n * market. The upper bound ratio represents the deviation between reported price (the price that’s being\n * validated) and the anchor price (the price we are validating against) above which the reported price will\n * be invalidated. The lower bound ratio presents the deviation between reported price and anchor price below\n * which the reported price will be invalidated. So for oracle price to be considered valid the below statement\n * should be true:\n\n```\nanchorRatio = anchorPrice/reporterPrice\nisValid = anchorRatio <= upperBoundAnchorRatio && anchorRatio >= lowerBoundAnchorRatio\n```\n\n * In most cases, Chainlink is used as the main oracle, TWAP or Pyth oracles are used as the pivot oracle depending\n * on which supports the given market and Binance oracle is used as the fallback oracle. For some markets we may\n * use Pyth or TWAP as the main oracle if the token price is not supported by Chainlink or Binance oracles.\n *\n * For a fetched price to be valid it must be positive and not stagnant. If the price is invalid then we consider the\n * oracle to be stagnant and treat it like it's disabled.\n */\ncontract ResilientOracle is PausableUpgradeable, AccessControlledV8, ResilientOracleInterface {\n /**\n * @dev Oracle roles:\n * **main**: The most trustworthy price source\n * **pivot**: Price oracle used as a loose sanity checker\n * **fallback**: The backup source when main oracle price is invalidated\n */\n enum OracleRole {\n MAIN,\n PIVOT,\n FALLBACK\n }\n\n struct TokenConfig {\n /// @notice asset address\n address asset;\n /// @notice `oracles` stores the oracles based on their role in the following order:\n /// [main, pivot, fallback],\n /// It can be indexed with the corresponding enum OracleRole value\n address[3] oracles;\n /// @notice `enableFlagsForOracles` stores the enabled state\n /// for each oracle in the same order as `oracles`\n bool[3] enableFlagsForOracles;\n }\n\n uint256 public constant INVALID_PRICE = 0;\n\n /// @notice Native market address\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n address public immutable nativeMarket;\n\n /// @notice VAI address\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n address public immutable vai;\n\n /// @notice Set this as asset address for Native token on each chain.This is the underlying for vBNB (on bsc)\n /// and can serve as any underlying asset of a market that supports native tokens\n address public constant NATIVE_TOKEN_ADDR = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\n\n /// @notice Bound validator contract address\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n BoundValidatorInterface public immutable boundValidator;\n\n mapping(address => TokenConfig) private tokenConfigs;\n\n event TokenConfigAdded(\n address indexed asset,\n address indexed mainOracle,\n address indexed pivotOracle,\n address fallbackOracle\n );\n\n /// Event emitted when an oracle is set\n event OracleSet(address indexed asset, address indexed oracle, uint256 indexed role);\n\n /// Event emitted when an oracle is enabled or disabled\n event OracleEnabled(address indexed asset, uint256 indexed role, bool indexed enable);\n\n /**\n * @notice Checks whether an address is null or not\n */\n modifier notNullAddress(address someone) {\n if (someone == address(0)) revert(\"can't be zero address\");\n _;\n }\n\n /**\n * @notice Checks whether token config exists by checking whether asset is null address\n * @dev address can't be null, so it's suitable to be used to check the validity of the config\n * @param asset asset address\n */\n modifier checkTokenConfigExistence(address asset) {\n if (tokenConfigs[asset].asset == address(0)) revert(\"token config must exist\");\n _;\n }\n\n /// @notice Constructor for the implementation contract. Sets immutable variables.\n /// @dev nativeMarketAddress can be address(0) if on the chain we do not support native market\n /// (e.g vETH on ethereum would not be supported, only vWETH)\n /// @param nativeMarketAddress The address of a native market (for bsc it would be vBNB address)\n /// @param vaiAddress The address of the VAI token (if there is VAI on the deployed chain).\n /// Set to address(0) of VAI is not existent.\n /// @param _boundValidator Address of the bound validator contract\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor(\n address nativeMarketAddress,\n address vaiAddress,\n BoundValidatorInterface _boundValidator\n ) notNullAddress(address(_boundValidator)) {\n nativeMarket = nativeMarketAddress;\n vai = vaiAddress;\n boundValidator = _boundValidator;\n\n _disableInitializers();\n }\n\n /**\n * @notice Initializes the contract admin and sets the BoundValidator contract address\n * @param accessControlManager_ Address of the access control manager contract\n */\n function initialize(address accessControlManager_) external initializer {\n __AccessControlled_init(accessControlManager_);\n __Pausable_init();\n }\n\n /**\n * @notice Pauses oracle\n * @custom:access Only Governance\n */\n function pause() external {\n _checkAccessAllowed(\"pause()\");\n _pause();\n }\n\n /**\n * @notice Unpauses oracle\n * @custom:access Only Governance\n */\n function unpause() external {\n _checkAccessAllowed(\"unpause()\");\n _unpause();\n }\n\n /**\n * @notice Batch sets token configs\n * @param tokenConfigs_ Token config array\n * @custom:access Only Governance\n * @custom:error Throws a length error if the length of the token configs array is 0\n */\n function setTokenConfigs(TokenConfig[] memory tokenConfigs_) external {\n if (tokenConfigs_.length == 0) revert(\"length can't be 0\");\n uint256 numTokenConfigs = tokenConfigs_.length;\n for (uint256 i; i < numTokenConfigs; ) {\n setTokenConfig(tokenConfigs_[i]);\n unchecked {\n ++i;\n }\n }\n }\n\n /**\n * @notice Sets oracle for a given asset and role.\n * @dev Supplied asset **must** exist and main oracle may not be null\n * @param asset Asset address\n * @param oracle Oracle address\n * @param role Oracle role\n * @custom:access Only Governance\n * @custom:error Null address error if main-role oracle address is null\n * @custom:error NotNullAddress error is thrown if asset address is null\n * @custom:error TokenConfigExistance error is thrown if token config is not set\n * @custom:event Emits OracleSet event with asset address, oracle address and role of the oracle for the asset\n */\n function setOracle(\n address asset,\n address oracle,\n OracleRole role\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\n _checkAccessAllowed(\"setOracle(address,address,uint8)\");\n if (oracle == address(0) && role == OracleRole.MAIN) revert(\"can't set zero address to main oracle\");\n tokenConfigs[asset].oracles[uint256(role)] = oracle;\n emit OracleSet(asset, oracle, uint256(role));\n }\n\n /**\n * @notice Enables/ disables oracle for the input asset. Token config for the input asset **must** exist\n * @dev Configuration for the asset **must** already exist and the asset cannot be 0 address\n * @param asset Asset address\n * @param role Oracle role\n * @param enable Enabled boolean of the oracle\n * @custom:access Only Governance\n * @custom:error NotNullAddress error is thrown if asset address is null\n * @custom:error TokenConfigExistance error is thrown if token config is not set\n */\n function enableOracle(\n address asset,\n OracleRole role,\n bool enable\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\n _checkAccessAllowed(\"enableOracle(address,uint8,bool)\");\n tokenConfigs[asset].enableFlagsForOracles[uint256(role)] = enable;\n emit OracleEnabled(asset, uint256(role), enable);\n }\n\n /**\n * @notice Updates the TWAP pivot oracle price.\n * @dev This function should always be called before calling getUnderlyingPrice\n * @param vToken vToken address\n */\n function updatePrice(address vToken) external override {\n address asset = _getUnderlyingAsset(vToken);\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\n if (pivotOracle != address(0) && pivotOracleEnabled) {\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\n }\n }\n\n /**\n * @notice Updates the pivot oracle price. Currently using TWAP\n * @dev This function should always be called before calling getPrice\n * @param asset asset address\n */\n function updateAssetPrice(address asset) external {\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\n if (pivotOracle != address(0) && pivotOracleEnabled) {\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\n }\n }\n\n /**\n * @dev Gets token config by asset address\n * @param asset asset address\n * @return tokenConfig Config for the asset\n */\n function getTokenConfig(address asset) external view returns (TokenConfig memory) {\n return tokenConfigs[asset];\n }\n\n /**\n * @notice Gets price of the underlying asset for a given vToken. Validation flow:\n * - Check if the oracle is paused globally\n * - Validate price from main oracle against pivot oracle\n * - Validate price from fallback oracle against pivot oracle if the first validation failed\n * - Validate price from main oracle against fallback oracle if the second validation failed\n * In the case that the pivot oracle is not available but main price is available and validation is successful,\n * main oracle price is returned.\n * @param vToken vToken address\n * @return price USD price in scaled decimal places.\n * @custom:error Paused error is thrown when resilent oracle is paused\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\n */\n function getUnderlyingPrice(address vToken) external view override returns (uint256) {\n if (paused()) revert(\"resilient oracle is paused\");\n\n address asset = _getUnderlyingAsset(vToken);\n return _getPrice(asset);\n }\n\n /**\n * @notice Gets price of the asset\n * @param asset asset address\n * @return price USD price in scaled decimal places.\n * @custom:error Paused error is thrown when resilent oracle is paused\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\n */\n function getPrice(address asset) external view override returns (uint256) {\n if (paused()) revert(\"resilient oracle is paused\");\n return _getPrice(asset);\n }\n\n /**\n * @notice Sets/resets single token configs.\n * @dev main oracle **must not** be a null address\n * @param tokenConfig Token config struct\n * @custom:access Only Governance\n * @custom:error NotNullAddress is thrown if asset address is null\n * @custom:error NotNullAddress is thrown if main-role oracle address for asset is null\n * @custom:event Emits TokenConfigAdded event when the asset config is set successfully by the authorized account\n */\n function setTokenConfig(\n TokenConfig memory tokenConfig\n ) public notNullAddress(tokenConfig.asset) notNullAddress(tokenConfig.oracles[uint256(OracleRole.MAIN)]) {\n _checkAccessAllowed(\"setTokenConfig(TokenConfig)\");\n\n tokenConfigs[tokenConfig.asset] = tokenConfig;\n emit TokenConfigAdded(\n tokenConfig.asset,\n tokenConfig.oracles[uint256(OracleRole.MAIN)],\n tokenConfig.oracles[uint256(OracleRole.PIVOT)],\n tokenConfig.oracles[uint256(OracleRole.FALLBACK)]\n );\n }\n\n /**\n * @notice Gets oracle and enabled status by asset address\n * @param asset asset address\n * @param role Oracle role\n * @return oracle Oracle address based on role\n * @return enabled Enabled flag of the oracle based on token config\n */\n function getOracle(address asset, OracleRole role) public view returns (address oracle, bool enabled) {\n oracle = tokenConfigs[asset].oracles[uint256(role)];\n enabled = tokenConfigs[asset].enableFlagsForOracles[uint256(role)];\n }\n\n function _getPrice(address asset) internal view returns (uint256) {\n uint256 pivotPrice = INVALID_PRICE;\n\n // Get pivot oracle price, Invalid price if not available or error\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\n if (pivotOracleEnabled && pivotOracle != address(0)) {\n try OracleInterface(pivotOracle).getPrice(asset) returns (uint256 pricePivot) {\n pivotPrice = pricePivot;\n } catch {}\n }\n\n // Compare main price and pivot price, return main price and if validation was successful\n // note: In case pivot oracle is not available but main price is available and\n // validation is successful, the main oracle price is returned.\n (uint256 mainPrice, bool validatedPivotMain) = _getMainOraclePrice(\n asset,\n pivotPrice,\n pivotOracleEnabled && pivotOracle != address(0)\n );\n if (mainPrice != INVALID_PRICE && validatedPivotMain) return mainPrice;\n\n // Compare fallback and pivot if main oracle comparision fails with pivot\n // Return fallback price when fallback price is validated successfully with pivot oracle\n (uint256 fallbackPrice, bool validatedPivotFallback) = _getFallbackOraclePrice(asset, pivotPrice);\n if (fallbackPrice != INVALID_PRICE && validatedPivotFallback) return fallbackPrice;\n\n // Lastly compare main price and fallback price\n if (\n mainPrice != INVALID_PRICE &&\n fallbackPrice != INVALID_PRICE &&\n boundValidator.validatePriceWithAnchorPrice(asset, mainPrice, fallbackPrice)\n ) {\n return mainPrice;\n }\n\n revert(\"invalid resilient oracle price\");\n }\n\n /**\n * @notice Gets a price for the provided asset\n * @dev This function won't revert when price is 0, because the fallback oracle may still be\n * able to fetch a correct price\n * @param asset asset address\n * @param pivotPrice Pivot oracle price\n * @param pivotEnabled If pivot oracle is not empty and enabled\n * @return price USD price in scaled decimals\n * e.g. asset decimals is 8 then price is returned as 10**18 * 10**(18-8) = 10**28 decimals\n * @return pivotValidated Boolean representing if the validation of main oracle price\n * and pivot oracle price were successful\n * @custom:error Invalid price error is thrown if main oracle fails to fetch price of the asset\n * @custom:error Invalid price error is thrown if main oracle is not enabled or main oracle\n * address is null\n */\n function _getMainOraclePrice(\n address asset,\n uint256 pivotPrice,\n bool pivotEnabled\n ) internal view returns (uint256, bool) {\n (address mainOracle, bool mainOracleEnabled) = getOracle(asset, OracleRole.MAIN);\n if (mainOracleEnabled && mainOracle != address(0)) {\n try OracleInterface(mainOracle).getPrice(asset) returns (uint256 mainOraclePrice) {\n if (!pivotEnabled) {\n return (mainOraclePrice, true);\n }\n if (pivotPrice == INVALID_PRICE) {\n return (mainOraclePrice, false);\n }\n return (\n mainOraclePrice,\n boundValidator.validatePriceWithAnchorPrice(asset, mainOraclePrice, pivotPrice)\n );\n } catch {\n return (INVALID_PRICE, false);\n }\n }\n\n return (INVALID_PRICE, false);\n }\n\n /**\n * @dev This function won't revert when the price is 0 because getPrice checks if price is > 0\n * @param asset asset address\n * @return price USD price in 18 decimals\n * @return pivotValidated Boolean representing if the validation of fallback oracle price\n * and pivot oracle price were successfully\n * @custom:error Invalid price error is thrown if fallback oracle fails to fetch price of the asset\n * @custom:error Invalid price error is thrown if fallback oracle is not enabled or fallback oracle\n * address is null\n */\n function _getFallbackOraclePrice(address asset, uint256 pivotPrice) private view returns (uint256, bool) {\n (address fallbackOracle, bool fallbackEnabled) = getOracle(asset, OracleRole.FALLBACK);\n if (fallbackEnabled && fallbackOracle != address(0)) {\n try OracleInterface(fallbackOracle).getPrice(asset) returns (uint256 fallbackOraclePrice) {\n if (pivotPrice == INVALID_PRICE) {\n return (fallbackOraclePrice, false);\n }\n return (\n fallbackOraclePrice,\n boundValidator.validatePriceWithAnchorPrice(asset, fallbackOraclePrice, pivotPrice)\n );\n } catch {\n return (INVALID_PRICE, false);\n }\n }\n\n return (INVALID_PRICE, false);\n }\n\n /**\n * @dev This function returns the underlying asset of a vToken\n * @param vToken vToken address\n * @return asset underlying asset address\n */\n function _getUnderlyingAsset(address vToken) private view notNullAddress(vToken) returns (address asset) {\n if (vToken == nativeMarket) {\n asset = NATIVE_TOKEN_ADDR;\n } else if (vToken == vai) {\n asset = vai;\n } else {\n asset = VBep20Interface(vToken).underlying();\n }\n }\n}\n" + }, + "@venusprotocol/solidity-utilities/contracts/constants.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\n/// @dev Base unit for computations, usually used in scaling (multiplications, divisions)\nuint256 constant EXP_SCALE = 1e18;\n\n/// @dev A unit (literal one) in EXP_SCALE, usually used in additions/subtractions\nuint256 constant MANTISSA_ONE = EXP_SCALE;\n\n/// @dev The approximate number of seconds per year\nuint256 constant SECONDS_PER_YEAR = 31_536_000;\n" + }, + "@venusprotocol/solidity-utilities/contracts/validators.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\n/// @notice Thrown if the supplied address is a zero address where it is not allowed\nerror ZeroAddressNotAllowed();\n\n/// @notice Thrown if the supplied value is 0 where it is not allowed\nerror ZeroValueNotAllowed();\n\n/// @notice Checks if the provided address is nonzero, reverts otherwise\n/// @param address_ Address to check\n/// @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address\nfunction ensureNonzeroAddress(address address_) pure {\n if (address_ == address(0)) {\n revert ZeroAddressNotAllowed();\n }\n}\n\n/// @notice Checks if the provided value is nonzero, reverts otherwise\n/// @param value_ Value to check\n/// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\nfunction ensureNonzeroValue(uint256 value_) pure {\n if (value_ == 0) {\n revert ZeroValueNotAllowed();\n }\n}\n" + }, + "contracts/Interfaces/IConverterNetwork.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport { IAbstractTokenConverter } from \"../TokenConverter/IAbstractTokenConverter.sol\";\n\n/**\n * @title IConverterNetwork\n * @author Venus\n * @notice Interface implemented by `ConverterNetwork`.\n */\ninterface IConverterNetwork {\n /// @notice Adds new converter to the array\n /// @param _tokenConverter Address of the token converter\n function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;\n\n /// @notice Removes converter from the array\n /// @param _tokenConverter Address of the token converter\n function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;\n\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\n /// @param _tokenAddressIn Address of tokenIn\n /// @param _tokenAddressOut Address of tokenOut\n /// @return converters Array of the conveters on the basis of the tokens pair\n /// @return convertersBalance Array of balances with respect to token out\n function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)\n external\n returns (address[] memory converters, uint256[] memory convertersBalance);\n\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\n /// @param _tokenAddressIn Address of tokenIn\n /// @param _tokenAddressOut Address of tokenOut\n /// @return converters Array of the conveters on the basis of the tokens pair\n /// @return convertersBalance Array of balances with respect to token out\n function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)\n external\n returns (address[] memory converters, uint256[] memory convertersBalance);\n\n /// @notice This function returns the array containing all the converters addresses\n /// @return Array containing all the converters addresses\n function getAllConverters() external view returns (IAbstractTokenConverter[] memory);\n\n /// @notice This function checks for given address is converter or not\n /// @param _tokenConverter Address of the token converter\n /// @return boolean true if given address is converter otherwise false\n function isTokenConverter(address _tokenConverter) external view returns (bool);\n}\n" + }, + "contracts/TokenConverter/AbstractTokenConverter.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\nimport { ReentrancyGuardUpgradeable } from \"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\";\nimport { SafeERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\nimport { AccessControlledV8 } from \"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\";\nimport { IERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\";\nimport { ResilientOracle } from \"@venusprotocol/oracle/contracts/ResilientOracle.sol\";\nimport { ensureNonzeroAddress, ensureNonzeroValue } from \"@venusprotocol/solidity-utilities/contracts/validators.sol\";\nimport { MANTISSA_ONE, EXP_SCALE } from \"@venusprotocol/solidity-utilities/contracts/constants.sol\";\n\nimport { IAbstractTokenConverter } from \"./IAbstractTokenConverter.sol\";\nimport { IConverterNetwork } from \"../Interfaces/IConverterNetwork.sol\";\n\n/// @title AbstractTokenConverter\n/// @author Venus\n/// @notice Abstract contract will be extended by SingleTokenConverter and RiskFundConverter\n/*\n * This contract specifies four functions for converting tokens, each applicable under following circumstances:\n *\n * Case I: TokenIn -> deflationary token, TokenOut -> deflationary token\n * In this scenario, functions supporting fees can only be utilized to convert tokens which are:\n * a. convertExactTokensSupportingFeeOnTransferTokens\n * b. convertForExactTokensSupportingFeeOnTransferTokens\n *\n * Case II: TokenIn -> deflationary token, TokenOut -> non-deflationary token\n * In this scenario, functions supporting fee can only be utilized to convert tokens which are:\n * similar to Case I.\n *\n * Case III: TokenIn -> non-deflationary token, TokenOut -> deflationary token\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\n * a. convertExactTokens\n * b. convertForExactTokens\n * c. convertExactTokensSupportingFeeOnTransferTokens\n * d. convertForExactTokensSupportingFeeOnTransferTokens\n *\n * Case IV: TokenIn -> non-deflationary token, TokenOut -> non-deflationary token\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\n * similar to Case III.\n *\n * ------------------------------------------------------------------------------------------------------------------------------------\n * Example 1:-\n * tokenInAddress - 0xaaaa.....\n * tokenOutAddress - 0xbbbb.....\n * tokenInAmount - 100\n * tokenOutMinAmount - minimum amount desired by the user(let's say 70)\n * Here user can use `convertExactTokens` or `convertExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\n * then `convertExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertExactTokens` is used).\n * Now first tokenInAddress tokens will be transferred from the user to the contract, on the basis of amount\n * received(as tokenInAddress can be deflationary token) tokenAmountOut will be calculated and will be transferred\n * to the user and if amount sent is less than tokenOutMinAmount, tx will revert. If amount sent is satisfied(let's say\n * 80 or even 70) then at last the actual amount received and the amount that was supposed to be received by the contract will\n * be compared, if they differ then the whole tx will revert as user was supposed to use `convertExactTokensSupportingFeeOnTransferTokens`\n * function for tokenIn as deflationary token.\n *\n * Example 2:-\n * tokenInAddress - 0xaaaa.....\n * tokenOutAddress - 0xbbbb.....\n * tokenInMaxAmount - maximum amount user is willing to provide(let's say 100)\n * tokenOutAmount - 70\n * Here user can use `convertForExactTokens` or `convertForExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\n * then `convertForExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertForExactTokens` is used),\n * which on the basis of tokenOutAmount provided will calculate tokenInAmount based on the tokens prices and will transfer\n * tokens from the user to the contract, now the actual amount received(as tokenInAddress can be deflationary token) will be\n * compared with tokenInMaxAmount if it is greater, tx will revert. If In amount is satisfied(let's say 90 or even 100) then\n * new tokenOutAmount will be calculated, and tokenOutAddress tokens will be transferred to the user, but at last the\n * old tokenOutAmount and new tokenOutAmount will be compared and if they differ whole tx will revert, because user was\n * supposed to use `convertForExactTokensSupportingFeeOnTransferTokens` function for tokenIn as deflationary token.\n * ------------------------------------------------------------------------------------------------------------------------------------\n *\n * This contract also supports private conversion between the converters:\n * Private conversions:\n * Private conversions is designed in order to convert the maximum amount of tokens received from PSR(to any converter) between\n * existing converters to save incentive and lower the dependency of users for conversion. So Private Conversion will be executed\n * by converters on it's own whenever funds are received from PSR. No incentive will be offered during private conversion.\n *\n * It will execute on updateAssetsState() function call in Converter Contracts. After this function call, converter will first\n * check for the amount received. If base asset is received then it will be directly sent to the destination address and no private\n * conversion will happen otherwise converter will interact with ConverterNetwork contract to find other valid converters who are providing the conversion for:\n *\n * tokenAddressIn: As asset received by that converter on updateAssetsState() function call.\n * tokenAddressOut: As base asset of that converter.\n *\n * ConverterNetwork:\n * This contract will contain all the converters, and will provide valid converters which can perform the execution according to tokenAddressIn\n * and tokenAddressOut provided.\n *\n * findTokenConverters():\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for users).\n *\n * findTokenConvertersForConverters():\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for converters).\n */\n\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\nabstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenConverter, ReentrancyGuardUpgradeable {\n using SafeERC20Upgradeable for IERC20Upgradeable;\n\n /// @notice Maximum incentive could be\n uint256 public constant MAX_INCENTIVE = 0.5e18;\n\n /// @notice Min amount to convert for private conversions. Defined in USD, with 18 decimals\n uint256 public minAmountToConvert;\n\n /// @notice Venus price oracle contract\n ResilientOracle public priceOracle;\n\n /// @notice conversion configurations for the existing pairs\n /// @dev tokenAddressIn => tokenAddressOut => ConversionConfig\n mapping(address => mapping(address => ConversionConfig)) public conversionConfigurations;\n\n /// @notice Address that all incoming tokens are transferred to\n address public destinationAddress;\n\n /// @notice Boolean for if conversion is paused\n bool public conversionPaused;\n\n /// @notice Address of the converterNetwork contract\n IConverterNetwork public converterNetwork;\n\n /// @dev This empty reserved space is put in place to allow future versions to add new\n /// variables without shifting down storage in the inheritance chain.\n /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n uint256[45] private __gap;\n\n /// @notice Emitted when config is updated for tokens pair\n event ConversionConfigUpdated(\n address indexed tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 oldIncentive,\n uint256 newIncentive,\n ConversionAccessibility oldAccess,\n ConversionAccessibility newAccess\n );\n /// @notice Emitted when price oracle address is updated\n event PriceOracleUpdated(ResilientOracle indexed oldPriceOracle, ResilientOracle indexed priceOracle);\n\n /// @notice Emitted when destination address is updated\n event DestinationAddressUpdated(address indexed oldDestinationAddress, address indexed destinationAddress);\n\n /// @notice Emitted when converterNetwork address is updated\n event ConverterNetworkAddressUpdated(address indexed oldConverterNetwork, address indexed converterNetwork);\n\n /// @notice Emitted when exact amount of tokens are converted for tokens\n event ConvertedExactTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when tokens are converted for exact amount of tokens\n event ConvertedForExactTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\n event ConvertedExactTokensSupportingFeeOnTransferTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\n event ConvertedForExactTokensSupportingFeeOnTransferTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when conversion is paused\n event ConversionPaused(address indexed sender);\n\n /// @notice Emitted when conversion is unpaused\n event ConversionResumed(address indexed sender);\n\n /// @notice Event emitted when tokens are swept\n event SweepToken(address indexed token, address indexed to, uint256 amount);\n\n /// @notice Emitted when minimum amount to convert is updated\n event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);\n\n /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\n error AmountOutMismatched();\n\n /// @notice Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\n error AmountInMismatched();\n\n /// @notice Thrown when given input amount is zero\n error InsufficientInputAmount();\n\n /// @notice Thrown when given output amount is zero\n error InsufficientOutputAmount();\n\n /// @notice Thrown when conversion is disabled or config does not exist for given pair\n error ConversionConfigNotEnabled();\n\n /// @notice Thrown when conversion is enabled only for private conversions\n error ConversionEnabledOnlyForPrivateConversions();\n\n /// @notice Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n error InvalidToAddress();\n\n /// @notice Thrown when incentive is higher than the MAX_INCENTIVE\n error IncentiveTooHigh(uint256 incentive, uint256 maxIncentive);\n\n /// @notice Thrown when amountOut is lower than amountOutMin\n error AmountOutLowerThanMinRequired(uint256 amountOutMantissa, uint256 amountOutMinMantissa);\n\n /// @notice Thrown when amountIn is higher than amountInMax\n error AmountInHigherThanMax(uint256 amountInMantissa, uint256 amountInMaxMantissa);\n\n /// @notice Thrown when conversion is paused\n error ConversionTokensPaused();\n\n /// @notice Thrown when conversion is Active\n error ConversionTokensActive();\n\n /// @notice Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\n error InvalidTokenConfigAddresses();\n\n /// @notice Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\n error InsufficientPoolLiquidity();\n\n /// @notice When address of the ConverterNetwork is not set or Zero address\n error InvalidConverterNetwork();\n\n /// @notice Thrown when trying to set non zero incentive for private conversion\n error NonZeroIncentiveForPrivateConversion();\n\n /// @notice Thrown when using convertForExactTokens deflationary tokens\n error DeflationaryTokenNotSupported();\n\n /// @notice Thrown when minimum amount to convert is zero\n error InvalidMinimumAmountToConvert();\n\n /// @notice Thrown when there is a mismatch in the length of input arrays\n error InputLengthMisMatch();\n\n /**\n * @notice Modifier to ensure valid conversion parameters for a token conversion\n * and check if conversion is paused or not\n * @param to The recipient address for the converted tokens\n * @param tokenAddressIn The input token address for the conversion\n * @param tokenAddressOut The output token address for the conversion\n */\n modifier validConversionParameters(\n address to,\n address tokenAddressIn,\n address tokenAddressOut\n ) {\n _checkConversionPaused();\n ensureNonzeroAddress(to);\n if (to == tokenAddressIn || to == tokenAddressOut) {\n revert InvalidToAddress();\n }\n _;\n }\n\n /// @notice Pause conversion of tokens\n /// @custom:event Emits ConversionPaused on success\n /// @custom:error ConversionTokensPaused thrown when conversion is already paused\n /// @custom:access Restricted by ACM\n function pauseConversion() external {\n _checkAccessAllowed(\"pauseConversion()\");\n _checkConversionPaused();\n conversionPaused = true;\n emit ConversionPaused(msg.sender);\n }\n\n /// @notice Resume conversion of tokens.\n /// @custom:event Emits ConversionResumed on success\n /// @custom:error ConversionTokensActive thrown when conversion is already active\n /// @custom:access Restricted by ACM\n function resumeConversion() external {\n _checkAccessAllowed(\"resumeConversion()\");\n if (!conversionPaused) {\n revert ConversionTokensActive();\n }\n\n conversionPaused = false;\n emit ConversionResumed(msg.sender);\n }\n\n /// @notice Sets a new price oracle\n /// @param priceOracle_ Address of the new price oracle to set\n /// @custom:access Only Governance\n function setPriceOracle(ResilientOracle priceOracle_) external onlyOwner {\n _setPriceOracle(priceOracle_);\n }\n\n /// @notice Sets a new destination address\n /// @param destinationAddress_ The new destination address to be set\n /// @custom:access Only Governance\n function setDestination(address destinationAddress_) external onlyOwner {\n _setDestination(destinationAddress_);\n }\n\n /// @notice Sets a converter network contract address\n /// @param converterNetwork_ The converterNetwork address to be set\n /// @custom:access Only Governance\n function setConverterNetwork(IConverterNetwork converterNetwork_) external onlyOwner {\n _setConverterNetwork(converterNetwork_);\n }\n\n /// @notice Min amount to convert setter\n /// @param minAmountToConvert_ Min amount to convert\n /// @custom:access Only Governance\n function setMinAmountToConvert(uint256 minAmountToConvert_) external {\n _checkAccessAllowed(\"setMinAmountToConvert(uint256)\");\n _setMinAmountToConvert(minAmountToConvert_);\n }\n\n /// @notice Batch sets the conversion configurations\n /// @param tokenAddressIn Address of tokenIn\n /// @param tokenAddressesOut Array of addresses of tokenOut\n /// @param conversionConfigs Array of conversionConfig config details to update\n /// @custom:error InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\n function setConversionConfigs(\n address tokenAddressIn,\n address[] calldata tokenAddressesOut,\n ConversionConfig[] calldata conversionConfigs\n ) external {\n uint256 tokenOutArrayLength = tokenAddressesOut.length;\n if (tokenOutArrayLength != conversionConfigs.length) revert InputLengthMisMatch();\n\n for (uint256 i; i < tokenOutArrayLength; ) {\n setConversionConfig(tokenAddressIn, tokenAddressesOut[i], conversionConfigs[i]);\n unchecked {\n ++i;\n }\n }\n }\n\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedExactTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n /// @custom:error AmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n function convertExactTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\n amountInMantissa,\n amountOutMinMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n if (actualAmountIn != amountInMantissa) {\n revert AmountInMismatched();\n }\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n }\n\n /// @notice Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract,\n /// otherwise the amount is adjusted\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedForExactTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n /// @custom:error AmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\n function convertForExactTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertForExactTokens(\n amountInMaxMantissa,\n amountOutMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n if (actualAmountOut != amountOutMantissa) {\n revert AmountOutMismatched();\n }\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedForExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n }\n\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n function convertExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\n amountInMantissa,\n amountOutMinMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedExactTokensSupportingFeeOnTransferTokens(\n msg.sender,\n to,\n tokenAddressIn,\n tokenAddressOut,\n actualAmountIn,\n actualAmountOut\n );\n }\n\n /// @notice Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of\n /// tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted.\n /// The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n function convertForExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertForExactTokensSupportingFeeOnTransferTokens(\n amountInMaxMantissa,\n amountOutMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedForExactTokensSupportingFeeOnTransferTokens(\n msg.sender,\n to,\n tokenAddressIn,\n tokenAddressOut,\n actualAmountIn,\n actualAmountOut\n );\n }\n\n /// @notice To sweep ERC20 tokens and transfer them to user(to address)\n /// @param tokenAddress The address of the ERC-20 token to sweep\n /// @param to The address to which tokens will be transferred\n /// @param amount The amount to transfer\n /// @custom:event Emits SweepToken event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\n /// @custom:access Only Governance\n function sweepToken(\n address tokenAddress,\n address to,\n uint256 amount\n ) external onlyOwner nonReentrant {\n ensureNonzeroAddress(tokenAddress);\n ensureNonzeroAddress(to);\n ensureNonzeroValue(amount);\n\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\n preSweepToken(tokenAddress, amount);\n token.safeTransfer(to, amount);\n\n emit SweepToken(tokenAddress, to, amount);\n }\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn.\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\n /// @notice The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\n /// @dev This function retrieves values without altering token prices\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\n function getAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\n if (\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\n ConversionAccessibility.ONLY_FOR_CONVERTERS\n ) {\n revert ConversionEnabledOnlyForPrivateConversions();\n }\n\n amountConvertedMantissa = amountInMantissa;\n uint256 tokenInToOutConversion;\n (amountOutMantissa, tokenInToOutConversion) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\n\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\n\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\n if (maxTokenOutReserve < amountOutMantissa) {\n amountConvertedMantissa = _divRoundingUp(maxTokenOutReserve * EXP_SCALE, tokenInToOutConversion);\n amountOutMantissa = maxTokenOutReserve;\n }\n }\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut.\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\n /// @dev This function retrieves values without altering token prices\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\n function getAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\n if (\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\n ConversionAccessibility.ONLY_FOR_CONVERTERS\n ) {\n revert ConversionEnabledOnlyForPrivateConversions();\n }\n\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\n\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\n if (maxTokenOutReserve < amountOutMantissa) {\n amountOutMantissa = maxTokenOutReserve;\n }\n\n amountConvertedMantissa = amountOutMantissa;\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n }\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) public returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\n priceOracle.updateAssetPrice(tokenAddressIn);\n priceOracle.updateAssetPrice(tokenAddressOut);\n\n (amountOutMantissa, ) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\n amountConvertedMantissa = amountInMantissa;\n }\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) public returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\n priceOracle.updateAssetPrice(tokenAddressIn);\n priceOracle.updateAssetPrice(tokenAddressOut);\n\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n amountConvertedMantissa = amountOutMantissa;\n }\n\n /// @notice This method updated the states of this contract after getting funds from PSR\n /// after settling the amount(if any) through privateConversion between converters\n /// @dev This function is called by protocolShareReserve\n /// @dev call _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then\n /// it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\n /// @param comptroller Comptroller address (pool)\n /// @param asset Asset address\n function updateAssetsState(address comptroller, address asset) public nonReentrant {\n uint256 balanceDiff = _updateAssetsState(comptroller, asset);\n if (balanceDiff > 0) {\n _privateConversion(comptroller, asset, balanceDiff);\n }\n }\n\n /// @notice Set the configuration for new or existing conversion pair\n /// @param tokenAddressIn Address of tokenIn\n /// @param tokenAddressOut Address of tokenOut\n /// @param conversionConfig ConversionConfig config details to update\n /// @custom:event Emits ConversionConfigUpdated event on success\n /// @custom:error Unauthorized error is thrown when the call is not authorized by AccessControlManager\n /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero\n /// @custom:error NonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\n /// @custom:access Controlled by AccessControlManager\n function setConversionConfig(\n address tokenAddressIn,\n address tokenAddressOut,\n ConversionConfig calldata conversionConfig\n ) public {\n _checkAccessAllowed(\"setConversionConfig(address,address,ConversionConfig)\");\n ensureNonzeroAddress(tokenAddressIn);\n ensureNonzeroAddress(tokenAddressOut);\n\n if (conversionConfig.incentive > MAX_INCENTIVE) {\n revert IncentiveTooHigh(conversionConfig.incentive, MAX_INCENTIVE);\n }\n\n if (\n (tokenAddressIn == tokenAddressOut) ||\n (tokenAddressIn != _getDestinationBaseAsset()) ||\n conversionConfigurations[tokenAddressOut][tokenAddressIn].conversionAccess != ConversionAccessibility.NONE\n ) {\n revert InvalidTokenConfigAddresses();\n }\n\n if (\n (conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) &&\n conversionConfig.incentive != 0\n ) {\n revert NonZeroIncentiveForPrivateConversion();\n }\n\n if (\n ((conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) ||\n (conversionConfig.conversionAccess == ConversionAccessibility.ALL)) &&\n (address(converterNetwork) == address(0))\n ) {\n revert InvalidConverterNetwork();\n }\n\n ConversionConfig storage configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\n\n emit ConversionConfigUpdated(\n tokenAddressIn,\n tokenAddressOut,\n configuration.incentive,\n conversionConfig.incentive,\n configuration.conversionAccess,\n conversionConfig.conversionAccess\n );\n\n if (conversionConfig.conversionAccess == ConversionAccessibility.NONE) {\n delete conversionConfigurations[tokenAddressIn][tokenAddressOut];\n } else {\n configuration.incentive = conversionConfig.incentive;\n configuration.conversionAccess = conversionConfig.conversionAccess;\n }\n }\n\n /// @notice Get the balance for specific token\n /// @param token Address of the token\n /// @return tokenBalance Balance of the token the contract has\n function balanceOf(address token) public view virtual returns (uint256 tokenBalance);\n\n /// @dev Operations to perform before sweeping tokens\n /// @param token Address of the token\n /// @param amount Amount transferred to address(to)\n function preSweepToken(address token, uint256 amount) internal virtual {}\n\n /// @dev Converts exact amount of tokenAddressIn for tokenAddressOut\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\n /// @return amountOutMantissa Actual amount of tokenAddressOut transferred\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n function _convertExactTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) internal returns (uint256 actualAmountIn, uint256 amountOutMantissa) {\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\n\n (, amountOutMantissa) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\n\n if (amountOutMantissa < amountOutMinMantissa) {\n revert AmountOutLowerThanMinRequired(amountOutMantissa, amountOutMinMantissa);\n }\n\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\n }\n\n /// @dev Converts tokens for tokenAddressIn for exact amount of tokenAddressOut used for non deflationry tokens\n /// it is called by convertForExactTokens function\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\n /// @custom:error DeflationaryTokenNotSupported is thrown if tokenAddressIn is deflationary token\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n function _convertForExactTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\n\n if (actualAmountIn != amountInMantissa) {\n revert DeflationaryTokenNotSupported();\n }\n\n if (actualAmountIn > amountInMaxMantissa) {\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\n }\n\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\n actualAmountOut = amountOutMantissa;\n }\n\n /// @dev Converts tokens for tokenAddressIn for the amount of tokenAddressOut used for deflationary tokens\n /// it is called by convertForExactTokensSupportingFeeOnTransferTokens function\n /// @notice Advising users to input a smaller amountOutMantissa to avoid potential transaction revert\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n function _convertForExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n\n if (amountInMantissa > amountInMaxMantissa) {\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\n }\n\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\n\n (, actualAmountOut) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\n\n _doTransferOut(tokenAddressOut, to, actualAmountOut);\n }\n\n /// @dev return actualAmountOut from reserves for tokenAddressOut\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred\n /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa\n function _doTransferOut(\n address tokenAddressOut,\n address to,\n uint256 amountConvertedMantissa\n ) internal {\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\n\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\n if (maxTokenOutReserve < amountConvertedMantissa) {\n revert InsufficientPoolLiquidity();\n }\n\n _preTransferHook(tokenAddressOut, amountConvertedMantissa);\n\n IERC20Upgradeable tokenOut = IERC20Upgradeable(tokenAddressOut);\n tokenOut.safeTransfer(to, amountConvertedMantissa);\n }\n\n /// @notice Transfer tokenAddressIn from user to destination\n /// @param tokenAddressIn Address of the token to convert\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @return actualAmountIn Actual amount transferred to destination\n function _doTransferIn(address tokenAddressIn, uint256 amountInMantissa) internal returns (uint256 actualAmountIn) {\n IERC20Upgradeable tokenIn = IERC20Upgradeable(tokenAddressIn);\n uint256 balanceBeforeDestination = tokenIn.balanceOf(destinationAddress);\n tokenIn.safeTransferFrom(msg.sender, destinationAddress, amountInMantissa);\n uint256 balanceAfterDestination = tokenIn.balanceOf(destinationAddress);\n actualAmountIn = balanceAfterDestination - balanceBeforeDestination;\n }\n\n /// @dev Sets a new price oracle\n /// @param priceOracle_ Address of the new price oracle to set\n /// @custom:event Emits PriceOracleUpdated event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero\n function _setPriceOracle(ResilientOracle priceOracle_) internal {\n ensureNonzeroAddress(address(priceOracle_));\n emit PriceOracleUpdated(priceOracle, priceOracle_);\n priceOracle = priceOracle_;\n }\n\n /// @dev Sets a new destination address\n /// @param destinationAddress_ The new destination address to be set\n /// @custom:event Emits DestinationAddressUpdated event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when destination address is zero\n function _setDestination(address destinationAddress_) internal {\n ensureNonzeroAddress(destinationAddress_);\n emit DestinationAddressUpdated(destinationAddress, destinationAddress_);\n destinationAddress = destinationAddress_;\n }\n\n /// @notice Sets a converter network contract address\n /// @param converterNetwork_ The converterNetwork address to be set\n /// @custom:event Emits ConverterNetworkAddressUpdated event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\n function _setConverterNetwork(IConverterNetwork converterNetwork_) internal {\n ensureNonzeroAddress(address(converterNetwork_));\n emit ConverterNetworkAddressUpdated(address(converterNetwork), address(converterNetwork_));\n converterNetwork = converterNetwork_;\n }\n\n /// @notice Min amount to convert setter\n /// @param minAmountToConvert_ Min amount to convert\n /// @custom:event MinAmountToConvertUpdated is emitted in success\n /// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\n function _setMinAmountToConvert(uint256 minAmountToConvert_) internal {\n ensureNonzeroValue(minAmountToConvert_);\n emit MinAmountToConvertUpdated(minAmountToConvert, minAmountToConvert_);\n minAmountToConvert = minAmountToConvert_;\n }\n\n /// @dev Hook to perform after converting tokens\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param amountIn Amount of tokenIn converted\n /// @param amountOut Amount of tokenOut converted\n function _postConversionHook(\n address tokenAddressIn,\n address tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n ) internal virtual {}\n\n /// @param accessControlManager_ Access control manager contract address\n /// @param priceOracle_ Resilient oracle address\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\n /// @param minAmountToConvert_ minimum amount to convert\n function __AbstractTokenConverter_init(\n address accessControlManager_,\n ResilientOracle priceOracle_,\n address destinationAddress_,\n uint256 minAmountToConvert_\n ) internal onlyInitializing {\n __AccessControlled_init(accessControlManager_);\n __ReentrancyGuard_init();\n __AbstractTokenConverter_init_unchained(priceOracle_, destinationAddress_, minAmountToConvert_);\n }\n\n /// @param priceOracle_ Resilient oracle address\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\n /// @param minAmountToConvert_ minimum amount to convert\n function __AbstractTokenConverter_init_unchained(\n ResilientOracle priceOracle_,\n address destinationAddress_,\n uint256 minAmountToConvert_\n ) internal onlyInitializing {\n _setPriceOracle(priceOracle_);\n _setDestination(destinationAddress_);\n _setMinAmountToConvert(minAmountToConvert_);\n conversionPaused = false;\n }\n\n /// @dev _updateAssetsState hook to update the states of reserves transferred for the specific comptroller\n /// @param comptroller Comptroller address (pool)\n /// @param asset Asset address\n /// @return Amount of asset, for _privateConversion\n function _updateAssetsState(address comptroller, address asset) internal virtual returns (uint256) {}\n\n /// @dev This method is used to convert asset into base asset by converting them with other converters which supports the pair and transfer the funds to\n /// destination contract as destination's base asset\n /// @param comptroller Comptroller address (pool)\n /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset\n /// @param amountToConvert Amount of the tokenAddressOut transferred to converter\n function _privateConversion(\n address comptroller,\n address tokenAddressOut,\n uint256 amountToConvert\n ) internal {\n address tokenAddressIn = _getDestinationBaseAsset();\n address _destinationAddress = destinationAddress;\n uint256 convertedTokenInBalance;\n if (address(converterNetwork) != address(0)) {\n (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork\n .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn);\n uint256 convertersLength = converterAddresses.length;\n for (uint256 i; i < convertersLength; ) {\n if (converterBalances[i] == 0) break;\n (, uint256 amountIn) = IAbstractTokenConverter(converterAddresses[i]).getUpdatedAmountIn(\n converterBalances[i],\n tokenAddressOut,\n tokenAddressIn\n );\n if (amountIn > amountToConvert) {\n amountIn = amountToConvert;\n }\n\n if (!_validateMinAmountToConvert(amountIn, tokenAddressOut)) {\n break;\n }\n\n uint256 balanceBefore = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\n\n IERC20Upgradeable(tokenAddressOut).forceApprove(converterAddresses[i], amountIn);\n IAbstractTokenConverter(converterAddresses[i]).convertExactTokens(\n amountIn,\n 0,\n tokenAddressOut,\n tokenAddressIn,\n _destinationAddress\n );\n\n uint256 balanceAfter = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\n amountToConvert -= amountIn;\n convertedTokenInBalance += (balanceAfter - balanceBefore);\n\n if (amountToConvert == 0) break;\n unchecked {\n ++i;\n }\n }\n }\n\n _postPrivateConversionHook(\n comptroller,\n tokenAddressIn,\n convertedTokenInBalance,\n tokenAddressOut,\n amountToConvert\n );\n }\n\n /// @dev This hook is used to update states for the converter after the privateConversion\n /// @param comptroller Comptroller address (pool)\n /// @param tokenAddressIn Address of the destination's base asset\n /// @param convertedTokenInBalance Amount of the base asset received after the conversion\n /// @param tokenAddressOut Address of the asset transferred to other converter in exchange of base asset\n /// @param convertedTokenOutBalance Amount of tokenAddressOut transferred from this converter\n function _postPrivateConversionHook(\n address comptroller,\n address tokenAddressIn,\n uint256 convertedTokenInBalance,\n address tokenAddressOut,\n uint256 convertedTokenOutBalance\n ) internal virtual {}\n\n /// @notice This hook is used to update the state for asset reserves before transferring tokenOut to user\n /// @param tokenOutAddress Address of the asset to be transferred to the user\n /// @param amountOut Amount of tokenAddressOut transferred from this converter\n function _preTransferHook(address tokenOutAddress, uint256 amountOut) internal virtual {}\n\n /// @dev Checks if amount to convert is greater than minimum amount to convert or not\n /// @param amountIn The amount to convert\n /// @param tokenAddress Address of the token\n /// @return isValid true if amount to convert is greater than minimum amount to convert\n function _validateMinAmountToConvert(uint256 amountIn, address tokenAddress) internal returns (bool isValid) {\n priceOracle.updateAssetPrice(tokenAddress);\n uint256 amountInInUsd = (priceOracle.getPrice(tokenAddress) * amountIn) / EXP_SCALE;\n\n if (amountInInUsd >= minAmountToConvert) {\n isValid = true;\n }\n }\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @dev This function retrieves values without altering token prices.\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function _getAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) internal view returns (uint256 amountOutMantissa, uint256 tokenInToOutConversion) {\n if (amountInMantissa == 0) {\n revert InsufficientInputAmount();\n }\n\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\n\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\n revert ConversionConfigNotEnabled();\n }\n\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\n\n uint256 incentive = configuration.incentive;\n if (address(converterNetwork) != address(0) && (converterNetwork.isTokenConverter(msg.sender))) {\n incentive = 0;\n }\n\n /// conversion rate after considering incentive(conversionWithIncentive)\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\n\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\n /// amount of tokenAddressOut after including incentive as amountOutMantissa will be greater than actual as it gets\n /// multiplied by conversionWithIncentive which will be >= 1\n amountOutMantissa = (amountInMantissa * tokenInToOutConversion) / (EXP_SCALE);\n }\n\n /// @dev To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @dev This function retrieves values without altering token prices.\n /// @dev For user conversions, the function returns an amountInMantissa that is rounded up, ensuring that the equivalent amountInMantissa\n /// is obtained from users for corresponding amountOutMantissa, preventing any losses to the protocol. However, no rounding up is required for private conversions\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function _getAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) internal view returns (uint256 amountInMantissa, uint256 tokenInToOutConversion) {\n if (amountOutMantissa == 0) {\n revert InsufficientOutputAmount();\n }\n\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\n\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\n revert ConversionConfigNotEnabled();\n }\n\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\n\n uint256 incentive = configuration.incentive;\n\n bool isPrivateConversion = address(converterNetwork) != address(0) &&\n converterNetwork.isTokenConverter(msg.sender);\n if (isPrivateConversion) {\n incentive = 0;\n }\n\n /// conversion rate after considering incentive(conversionWithIncentive)\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\n\n /// amount of tokenAddressIn after considering incentive(i.e. amountInMantissa will be less than actual amountInMantissa if incentive > 0)\n if (isPrivateConversion) {\n amountInMantissa =\n (amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE) /\n (tokenInUnderlyingPrice * conversionWithIncentive);\n } else {\n amountInMantissa = _divRoundingUp(\n amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE,\n tokenInUnderlyingPrice * conversionWithIncentive\n );\n }\n\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\n }\n\n /// @dev Check if msg.sender is allowed to convert as per onlyForPrivateConversions flag\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\n function _checkPrivateConversion(address tokenAddressIn, address tokenAddressOut) internal view {\n bool isConverter = (address(converterNetwork) != address(0)) && converterNetwork.isTokenConverter(msg.sender);\n if (\n (!(isConverter) &&\n (conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\n ConversionAccessibility.ONLY_FOR_CONVERTERS))\n ) {\n revert ConversionEnabledOnlyForPrivateConversions();\n }\n }\n\n /// @dev To check, is conversion paused\n /// @custom:error ConversionTokensPaused is thrown when token conversion is paused\n function _checkConversionPaused() internal view {\n if (conversionPaused) {\n revert ConversionTokensPaused();\n }\n }\n\n /// @dev Get base asset address of the destination contract\n /// @return Address of the base asset\n function _getDestinationBaseAsset() internal view virtual returns (address) {}\n\n /// @dev Performs division where the result is rounded up\n /// @param numerator The numerator of the division operation\n /// @param denominator The denominator of the division operation. Must be non-zero\n /// @return The result of the division, rounded up\n function _divRoundingUp(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\n return (numerator + denominator - 1) / denominator;\n }\n}\n" + }, + "contracts/TokenConverter/IAbstractTokenConverter.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport { ResilientOracle } from \"@venusprotocol/oracle/contracts/ResilientOracle.sol\";\nimport { IConverterNetwork } from \"../Interfaces/IConverterNetwork.sol\";\n\n/// @notice Interface for AbstractTokenConverter\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\ninterface IAbstractTokenConverter {\n /// @notice This enum define the all possible ways of conversion can happen\n enum ConversionAccessibility {\n NONE, // Conversion is disable for the pair\n ALL, // Conversion is enable for private conversion and users\n ONLY_FOR_CONVERTERS, // Conversion is enable only for private conversion\n ONLY_FOR_USERS // Conversion is enable only for users\n }\n\n /// @notice This struct represents the configuration for a token conversion.\n struct ConversionConfig {\n /// incentive on conversion of tokens in mantissa i.e 10% incentive would be 0.1 * 1e18\n uint256 incentive;\n /// enable or disable conversion for users or converters or both or none\n ConversionAccessibility conversionAccess;\n }\n\n /// @notice Pause conversion of tokens\n function pauseConversion() external;\n\n /// @notice Resume conversion of tokens.\n function resumeConversion() external;\n\n /// @notice Sets a new price oracle\n /// @param priceOracle_ Address of the new price oracle to set\n function setPriceOracle(ResilientOracle priceOracle_) external;\n\n /// @notice Set the configuration for new or existing convert pair\n /// @param tokenAddressIn Address of tokenIn\n /// @param tokenAddressOut Address of tokenOut\n /// @param conversionConfig ConversionConfig config details to update\n function setConversionConfig(\n address tokenAddressIn,\n address tokenAddressOut,\n ConversionConfig calldata conversionConfig\n ) external;\n\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertExactTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertForExactTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertForExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Get the configuration for the pair of the tokens\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return incentives Percentage of incentives to be distributed for the pair of tokens\n /// @return conversionAccess Accessibility for the pair of tokens\n function conversionConfigurations(address tokenAddressIn, address tokenAddressOut)\n external\n returns (uint256 incentives, ConversionAccessibility conversionAccess);\n\n /// @notice Get the address of the converterNetwork\n function converterNetwork() external returns (IConverterNetwork converterNetwork);\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @dev This function retrieves values without altering token prices.\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @dev This function retrieves values without altering token prices.\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\n\n /// @notice Get the balance for specific token\n /// @param token Address of the token\n /// @return tokenBalance Balance of the token the contract has\n function balanceOf(address token) external view returns (uint256 tokenBalance);\n}\n" + }, + "contracts/TokenConverter/SingleTokenConverter.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\nimport { SafeERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\nimport { IERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\";\nimport { ResilientOracle } from \"@venusprotocol/oracle/contracts/ResilientOracle.sol\";\nimport { ensureNonzeroAddress } from \"@venusprotocol/solidity-utilities/contracts/validators.sol\";\n\nimport { AbstractTokenConverter } from \"./AbstractTokenConverter.sol\";\n\n/// @title SingleTokenConverter\n/// @author Venus\n/// @notice SingleTokenConverter used for token conversions and sends received tokens\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\ncontract SingleTokenConverter is AbstractTokenConverter {\n using SafeERC20Upgradeable for IERC20Upgradeable;\n\n /// @notice Address of the base asset token\n address public baseAsset;\n\n /// @notice The mapping contains the assets which are sent to destination directly\n /// @dev Asset -> bool(should transfer directly on true)\n mapping(address => bool) public assetsDirectTransfer;\n\n /// @notice Emitted when base asset is updated\n event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset);\n\n /// @notice Emmitted after the funds transferred to the destination address\n event AssetTransferredToDestination(\n address indexed receiver,\n address indexed comptroller,\n address indexed asset,\n uint256 amount\n );\n\n /// @notice Emitted after the assetsDirectTransfer mapping is updated\n event AssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value);\n\n /// @notice Thrown when the base asset is the same as the new base asset\n error SameBaseAssetNotAllowed();\n\n /// @notice Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection\n error DirectTransferBaseAssetNotAllowed();\n\n /// @notice Thrown when the `assetsDirectTransfer[asset]` is already `value`\n /// @param asset The asset address whose `assetDirectTransfer` value went to be set\n /// @param value The value to be set\n error SameAssetDirectTransferNotAllowed(address asset, bool value);\n\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor() {\n // Note that the contract is upgradeable. Use initialize() or reinitializers\n // to set the state variables.\n _disableInitializers();\n }\n\n /// @param accessControlManager_ Access control manager contract address\n /// @param priceOracle_ Resilient oracle address\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\n /// @param baseAsset_ Address of the base asset\n /// @param minAmountToConvert_ Minimum amount to convert\n function initialize(\n address accessControlManager_,\n ResilientOracle priceOracle_,\n address destinationAddress_,\n address baseAsset_,\n uint256 minAmountToConvert_\n ) public initializer {\n _setBaseAsset(baseAsset_);\n\n // Initialize AbstractTokenConverter\n __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);\n }\n\n /// @notice Sets the base asset for the contract\n /// @param baseAsset_ The new address of the base asset\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\n /// @custom:event BaseAssetUpdated is emitted on success\n /// @custom:access Only Governance\n function setBaseAsset(address baseAsset_) external onlyOwner {\n _setBaseAsset(baseAsset_);\n }\n\n /// @notice Update the assetsDirectTransfer mapping\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\n /// @custom:event AssetsDirectTransferUpdated emits on success\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\n /// @custom:access Restricted by ACM\n function setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) external virtual {\n _checkAccessAllowed(\"setAssetsDirectTransfer(address[],bool[])\");\n _setAssetsDirectTransfer(assets, values);\n }\n\n /// @notice Get the balance for specific token\n /// @param tokenAddress Address of the token\n /// @return tokenBalance Balance of the token the contract has\n function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\n tokenBalance = token.balanceOf(address(this));\n }\n\n /// @dev It returns the balance of the `asset` in this contract. If `asset` is the `baseAsset`\n /// or `assetsDirectTransfer[asset]` is true, then the balance of `asset` in this contract will\n /// be transferred to the `destinationAddress` and 0 will be returned\n /// @param comptroller Comptroller address (pool)\n /// @param asset Asset address.\n /// @return balanceLeft Amount of asset, for _privateConversion\n function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) {\n IERC20Upgradeable token = IERC20Upgradeable(asset);\n uint256 balance = token.balanceOf(address(this));\n balanceLeft = balance;\n\n if (asset == baseAsset || assetsDirectTransfer[asset]) {\n balanceLeft = 0;\n token.safeTransfer(destinationAddress, balance);\n emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance);\n }\n }\n\n /// @notice Hook called after a private conversion is completed\n /// @dev Emits an AssetTransferredToDestination event if Private Conversion happens\n /// @param comptroller The address of the comptroller (pool) associated with the conversion\n /// @param tokenAddressIn The address of the input token that was converted\n /// @param convertedTokenInBalance The amount of input token that was converted\n /// @custom:event AssetTransferredToDestination Emitted when convertedTokenInBalance > 0, indicating\n /// the converted assets were transferred to the destination address\n function _postPrivateConversionHook(\n address comptroller,\n address tokenAddressIn,\n uint256 convertedTokenInBalance,\n address,\n uint256\n ) internal override {\n if (convertedTokenInBalance > 0) {\n emit AssetTransferredToDestination(\n destinationAddress,\n comptroller,\n tokenAddressIn,\n convertedTokenInBalance\n );\n }\n }\n\n /// @dev Update the assetsDirectTransfer mapping for destinationAddress\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\n /// @custom:event AssetsDirectTransferUpdated emits on success\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\n /// @custom:error DirectTransferBaseAssetNotAllowed thrown when an asset in `assets` is the `baseAsset`\n /// @custom:error SameAssetDirectTransferNotAllowed thrown when the value to set for an asset doesn't differs\n /// from its current value\n function _setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) internal {\n uint256 assetsLength = assets.length;\n\n if (assetsLength != values.length) {\n revert InputLengthMisMatch();\n }\n\n for (uint256 i; i < assetsLength; ++i) {\n if (assets[i] == baseAsset) {\n revert DirectTransferBaseAssetNotAllowed();\n }\n\n if (assetsDirectTransfer[assets[i]] == values[i]) {\n revert SameAssetDirectTransferNotAllowed(assets[i], values[i]);\n }\n\n assetsDirectTransfer[assets[i]] = values[i];\n emit AssetsDirectTransferUpdated(destinationAddress, assets[i], values[i]);\n }\n }\n\n /// @dev Sets the base asset for the contract\n /// @param baseAsset_ The new address of the base asset\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\n /// @custom:event BaseAssetUpdated is emitted on success\n function _setBaseAsset(address baseAsset_) internal {\n ensureNonzeroAddress(baseAsset_);\n\n if (baseAsset == baseAsset_) {\n revert SameBaseAssetNotAllowed();\n }\n\n emit BaseAssetUpdated(baseAsset, baseAsset_);\n baseAsset = baseAsset_;\n }\n\n /// @dev Get base asset address\n /// @return destinationBaseAsset Address of the base asset(baseAsset)\n function _getDestinationBaseAsset() internal view override returns (address destinationBaseAsset) {\n destinationBaseAsset = baseAsset;\n }\n}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 10000 + }, + "evmVersion": "paris", + "outputSelection": { + "*": { + "*": [ + "storageLayout", + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "evm.gasEstimates" + ], + "": ["ast"] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} diff --git a/deployments/bscmainnet/SingleTokenConverterImp.json b/deployments/bscmainnet/SingleTokenConverterImp.json index 45237a2c..f3866a87 100644 --- a/deployments/bscmainnet/SingleTokenConverterImp.json +++ b/deployments/bscmainnet/SingleTokenConverterImp.json @@ -1,5 +1,5 @@ { - "address": "0xF96363e03D175eEcc6A965f117e1497EAe878d29", + "address": "0x5583F7EE905744c6e96597215852D1eeb8E5b870", "abi": [ { "inputs": [], @@ -73,6 +73,11 @@ "name": "DeflationaryTokenNotSupported", "type": "error" }, + { + "inputs": [], + "name": "DirectTransferBaseAssetNotAllowed", + "type": "error" + }, { "inputs": [ { @@ -134,6 +139,27 @@ "name": "NonZeroIncentiveForPrivateConversion", "type": "error" }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "bool", + "name": "value", + "type": "bool" + } + ], + "name": "SameAssetDirectTransferNotAllowed", + "type": "error" + }, + { + "inputs": [], + "name": "SameBaseAssetNotAllowed", + "type": "error" + }, { "inputs": [ { @@ -196,6 +222,31 @@ "name": "AssetTransferredToDestination", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "value", + "type": "bool" + } + ], + "name": "AssetsDirectTransferUpdated", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -660,6 +711,25 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "assetsDirectTransfer", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [ { @@ -1191,6 +1261,24 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "assets", + "type": "address[]" + }, + { + "internalType": "bool[]", + "name": "values", + "type": "bool[]" + } + ], + "name": "setAssetsDirectTransfer", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -1381,42 +1469,52 @@ "type": "function" } ], - "transactionHash": "0x08052890322a63931c8784d25f8c388bd617397224d3cec841475dccf1401f02", + "transactionHash": "0xb48a05f9392f023891f6da5d811d9188e26c2eb98391c7847176a0e435407b54", "receipt": { "to": null, - "from": "0x7Bf1Fe2C42E79dbA813Bf5026B7720935a55ec5f", - "contractAddress": "0xF96363e03D175eEcc6A965f117e1497EAe878d29", - "transactionIndex": 104, - "gasUsed": "3704308", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000010000000000000400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0x5ddea9bbcbe36df924ba595597484c8074f56cd5d68d6537ed5b6a4305d5ecc0", - "transactionHash": "0x08052890322a63931c8784d25f8c388bd617397224d3cec841475dccf1401f02", + "from": "0x7A27Eb983eABc20CC68759Ec89227f4ae5656347", + "contractAddress": "0x5583F7EE905744c6e96597215852D1eeb8E5b870", + "transactionIndex": 50, + "gasUsed": "3964545", + "logsBloom": "0x00000000000000000000000000000800000000000000000000000000000000000000000000000000200000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x3dc7d38421dbe960bdc023af7d2686f816c72bd7ef130367487e5d5988134533", + "transactionHash": "0xb48a05f9392f023891f6da5d811d9188e26c2eb98391c7847176a0e435407b54", "logs": [ { - "transactionIndex": 104, - "blockNumber": 53536264, - "transactionHash": "0x08052890322a63931c8784d25f8c388bd617397224d3cec841475dccf1401f02", - "address": "0xF96363e03D175eEcc6A965f117e1497EAe878d29", + "transactionIndex": 50, + "blockNumber": 58239053, + "transactionHash": "0xb48a05f9392f023891f6da5d811d9188e26c2eb98391c7847176a0e435407b54", + "address": "0x5583F7EE905744c6e96597215852D1eeb8E5b870", "topics": ["0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498"], "data": "0x00000000000000000000000000000000000000000000000000000000000000ff", - "logIndex": 548, - "blockHash": "0x5ddea9bbcbe36df924ba595597484c8074f56cd5d68d6537ed5b6a4305d5ecc0" + "logIndex": 335, + "blockHash": "0x3dc7d38421dbe960bdc023af7d2686f816c72bd7ef130367487e5d5988134533" } ], - "blockNumber": 53536264, - "cumulativeGasUsed": "19429972", + "blockNumber": 58239053, + "cumulativeGasUsed": "13509796", "status": 1, "byzantium": true }, "args": [], - "numDeployments": 3, - "solcInputHash": "e2c9962896c0d2548025c54c4fbe3c77", - "metadata": "{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountInHigherThanMax\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountInMismatched\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountOutLowerThanMinRequired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountOutMismatched\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionConfigNotEnabled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionEnabledOnlyForPrivateConversions\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensActive\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensPaused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DeflationaryTokenNotSupported\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxIncentive\",\"type\":\"uint256\"}],\"name\":\"IncentiveTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InputLengthMisMatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientInputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientOutputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientPoolLiquidity\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidConverterNetwork\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidMinimumAmountToConvert\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidToAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenConfigAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NonZeroIncentiveForPrivateConversion\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"calledContract\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"methodSignature\",\"type\":\"string\"}],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddressNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroValueNotAllowed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"AssetTransferredToDestination\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldBaseAsset\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newBaseAsset\",\"type\":\"address\"}],\"name\":\"BaseAssetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"oldAccess\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"newAccess\",\"type\":\"uint8\"}],\"name\":\"ConversionConfigUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionResumed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldConverterNetwork\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"converterNetwork\",\"type\":\"address\"}],\"name\":\"ConverterNetworkAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldDestinationAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"}],\"name\":\"DestinationAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldMinAmountToConvert\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newMinAmountToConvert\",\"type\":\"uint256\"}],\"name\":\"MinAmountToConvertUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldAccessControlManager\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAccessControlManager\",\"type\":\"address\"}],\"name\":\"NewAccessControlManager\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"oldPriceOracle\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle\",\"type\":\"address\"}],\"name\":\"PriceOracleUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SweepToken\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MAX_INCENTIVE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"accessControlManager\",\"outputs\":[{\"internalType\":\"contract IAccessControlManagerV8\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"baseAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"conversionConfigurations\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"conversionPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"converterNetwork\",\"outputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"destinationAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"},{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minAmountToConvert\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"priceOracle\",\"outputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"}],\"name\":\"setAccessControlManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"}],\"name\":\"setBaseAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig\",\"name\":\"conversionConfig\",\"type\":\"tuple\"}],\"name\":\"setConversionConfig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"tokenAddressesOut\",\"type\":\"address[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig[]\",\"name\":\"conversionConfigs\",\"type\":\"tuple[]\"}],\"name\":\"setConversionConfigs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"converterNetwork_\",\"type\":\"address\"}],\"name\":\"setConverterNetwork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"}],\"name\":\"setDestination\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"setMinAmountToConvert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"}],\"name\":\"setPriceOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sweepToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"updateAssetsState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Venus\",\"custom:security-contact\":\"https://github.com/VenusProtocol/protocol-reserve#discussion\",\"events\":{\"Initialized(uint8)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"}},\"kind\":\"dev\",\"methods\":{\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"balanceOf(address)\":{\"params\":{\"tokenAddress\":\"Address of the token\"},\"returns\":{\"tokenBalance\":\"Balance of the token the contract has\"}},\"constructor\":{\"custom:oz-upgrades-unsafe-allow\":\"constructor\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissaAmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissaAmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\",\"custom:event\":\"Emits ConvertedForExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\",\"custom:event\":\"Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"getAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"getUpdatedAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getUpdatedAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"initialize(address,address,address,address,uint256)\":{\"params\":{\"accessControlManager_\":\"Access control manager contract address\",\"baseAsset_\":\"Address of the base asset\",\"destinationAddress_\":\"Address at all incoming tokens will transferred to\",\"minAmountToConvert_\":\"Minimum amount to convert\",\"priceOracle_\":\"Resilient oracle address\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pauseConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensPaused thrown when conversion is already paused\",\"custom:event\":\"Emits ConversionPaused on success\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"resumeConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensActive thrown when conversion is already active\",\"custom:event\":\"Emits ConversionResumed on success\"},\"setAccessControlManager(address)\":{\"custom:access\":\"Only Governance\",\"custom:event\":\"Emits NewAccessControlManager event\",\"details\":\"Admin function to set address of AccessControlManager\",\"params\":{\"accessControlManager_\":\"The new address of the AccessControlManager\"}},\"setBaseAsset(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"baseAsset_\":\"The new address of the base asset\"}},\"setConversionConfig(address,address,(uint256,uint8))\":{\"custom:access\":\"Controlled by AccessControlManager\",\"custom:error\":\"Unauthorized error is thrown when the call is not authorized by AccessControlManagerZeroAddressNotAllowed is thrown when pool registry address is zeroNonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\",\"custom:event\":\"Emits ConversionConfigUpdated event on success\",\"params\":{\"conversionConfig\":\"ConversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressOut\":\"Address of tokenOut\"}},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"custom:error\":\"InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\",\"params\":{\"conversionConfigs\":\"Array of conversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressesOut\":\"Array of addresses of tokenOut\"}},\"setConverterNetwork(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"converterNetwork_\":\"The converterNetwork address to be set\"}},\"setDestination(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"destinationAddress_\":\"The new destination address to be set\"}},\"setMinAmountToConvert(uint256)\":{\"custom:access\":\"Only Governance\",\"params\":{\"minAmountToConvert_\":\"Min amount to convert\"}},\"setPriceOracle(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"priceOracle_\":\"Address of the new price oracle to set\"}},\"sweepToken(address,address,uint256)\":{\"custom:access\":\"Only Governance\",\"custom:error\":\"ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\",\"custom:event\":\"Emits SweepToken event on success\",\"params\":{\"amount\":\"The amount to transfer\",\"to\":\"The address to which tokens will be transferred\",\"tokenAddress\":\"The address of the ERC-20 token to sweep\"}},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner.\"},\"updateAssetsState(address,address)\":{\"details\":\"This function is called by protocolShareReservecall _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\",\"params\":{\"asset\":\"Asset address\",\"comptroller\":\"Comptroller address (pool)\"}}},\"title\":\"SingleTokenConverter\",\"version\":1},\"userdoc\":{\"errors\":{\"AmountInHigherThanMax(uint256,uint256)\":[{\"notice\":\"Thrown when amountIn is higher than amountInMax\"}],\"AmountInMismatched()\":[{\"notice\":\"Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\"}],\"AmountOutLowerThanMinRequired(uint256,uint256)\":[{\"notice\":\"Thrown when amountOut is lower than amountOutMin\"}],\"AmountOutMismatched()\":[{\"notice\":\"Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\"}],\"ConversionConfigNotEnabled()\":[{\"notice\":\"Thrown when conversion is disabled or config does not exist for given pair\"}],\"ConversionEnabledOnlyForPrivateConversions()\":[{\"notice\":\"Thrown when conversion is enabled only for private conversions\"}],\"ConversionTokensActive()\":[{\"notice\":\"Thrown when conversion is Active\"}],\"ConversionTokensPaused()\":[{\"notice\":\"Thrown when conversion is paused\"}],\"DeflationaryTokenNotSupported()\":[{\"notice\":\"Thrown when using convertForExactTokens deflationary tokens\"}],\"IncentiveTooHigh(uint256,uint256)\":[{\"notice\":\"Thrown when incentive is higher than the MAX_INCENTIVE\"}],\"InputLengthMisMatch()\":[{\"notice\":\"Thrown when there is a mismatch in the length of input arrays\"}],\"InsufficientInputAmount()\":[{\"notice\":\"Thrown when given input amount is zero\"}],\"InsufficientOutputAmount()\":[{\"notice\":\"Thrown when given output amount is zero\"}],\"InsufficientPoolLiquidity()\":[{\"notice\":\"Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\"}],\"InvalidConverterNetwork()\":[{\"notice\":\"When address of the ConverterNetwork is not set or Zero address\"}],\"InvalidMinimumAmountToConvert()\":[{\"notice\":\"Thrown when minimum amount to convert is zero\"}],\"InvalidToAddress()\":[{\"notice\":\"Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\"}],\"InvalidTokenConfigAddresses()\":[{\"notice\":\"Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\"}],\"NonZeroIncentiveForPrivateConversion()\":[{\"notice\":\"Thrown when trying to set non zero incentive for private conversion\"}],\"Unauthorized(address,address,string)\":[{\"notice\":\"Thrown when the action is prohibited by AccessControlManager\"}],\"ZeroAddressNotAllowed()\":[{\"notice\":\"Thrown if the supplied address is a zero address where it is not allowed\"}],\"ZeroValueNotAllowed()\":[{\"notice\":\"Thrown if the supplied value is 0 where it is not allowed\"}]},\"events\":{\"AssetTransferredToDestination(address,address,address,uint256)\":{\"notice\":\"Emmitted after the funds transferred to the destination address\"},\"BaseAssetUpdated(address,address)\":{\"notice\":\"Emitted when base asset is updated\"},\"ConversionConfigUpdated(address,address,uint256,uint256,uint8,uint8)\":{\"notice\":\"Emitted when config is updated for tokens pair\"},\"ConversionPaused(address)\":{\"notice\":\"Emitted when conversion is paused\"},\"ConversionResumed(address)\":{\"notice\":\"Emitted when conversion is unpaused\"},\"ConvertedExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens\"},\"ConvertedExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\"},\"ConvertedForExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens\"},\"ConvertedForExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\"},\"ConverterNetworkAddressUpdated(address,address)\":{\"notice\":\"Emitted when converterNetwork address is updated\"},\"DestinationAddressUpdated(address,address)\":{\"notice\":\"Emitted when destination address is updated\"},\"MinAmountToConvertUpdated(uint256,uint256)\":{\"notice\":\"Emitted when minimum amount to convert is updated\"},\"NewAccessControlManager(address,address)\":{\"notice\":\"Emitted when access control manager contract address is changed\"},\"PriceOracleUpdated(address,address)\":{\"notice\":\"Emitted when price oracle address is updated\"},\"SweepToken(address,address,uint256)\":{\"notice\":\"Event emitted when tokens are swept\"}},\"kind\":\"user\",\"methods\":{\"MAX_INCENTIVE()\":{\"notice\":\"Maximum incentive could be\"},\"accessControlManager()\":{\"notice\":\"Returns the address of the access control manager contract\"},\"balanceOf(address)\":{\"notice\":\"Get the balance for specific token\"},\"baseAsset()\":{\"notice\":\"Address of the base asset token\"},\"conversionConfigurations(address,address)\":{\"notice\":\"conversion configurations for the existing pairs\"},\"conversionPaused()\":{\"notice\":\"Boolean for if conversion is paused\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract, otherwise the amount is adjusted\"},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted. The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\"},\"converterNetwork()\":{\"notice\":\"Address of the converterNetwork contract\"},\"destinationAddress()\":{\"notice\":\"Address that all incoming tokens are transferred to\"},\"getAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut. This function does not account for potential token transfer fees(in case of deflationary tokens)\"},\"getAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn. This function does not account for potential token transfer fees(in case of deflationary tokens)The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\"},\"getUpdatedAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\"},\"getUpdatedAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\"},\"minAmountToConvert()\":{\"notice\":\"Min amount to convert for private conversions. Defined in USD, with 18 decimals\"},\"pauseConversion()\":{\"notice\":\"Pause conversion of tokens\"},\"priceOracle()\":{\"notice\":\"Venus price oracle contract\"},\"resumeConversion()\":{\"notice\":\"Resume conversion of tokens.\"},\"setAccessControlManager(address)\":{\"notice\":\"Sets the address of AccessControlManager\"},\"setBaseAsset(address)\":{\"notice\":\"Sets the base asset for the contract\"},\"setConversionConfig(address,address,(uint256,uint8))\":{\"notice\":\"Set the configuration for new or existing conversion pair\"},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"notice\":\"Batch sets the conversion configurations\"},\"setConverterNetwork(address)\":{\"notice\":\"Sets a converter network contract address\"},\"setDestination(address)\":{\"notice\":\"Sets a new destination address\"},\"setMinAmountToConvert(uint256)\":{\"notice\":\"Min amount to convert setter\"},\"setPriceOracle(address)\":{\"notice\":\"Sets a new price oracle\"},\"sweepToken(address,address,uint256)\":{\"notice\":\"To sweep ERC20 tokens and transfer them to user(to address)\"},\"updateAssetsState(address,address)\":{\"notice\":\"This method updated the states of this contract after getting funds from PSR after settling the amount(if any) through privateConversion between converters\"}},\"notice\":\"SingleTokenConverter used for token conversions and sends received tokens\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/TokenConverter/SingleTokenConverter.sol\":\"SingleTokenConverter\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./OwnableUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership} and {acceptOwnership}.\\n *\\n * This module is used through inheritance. It will make available all functions\\n * from parent (Ownable).\\n */\\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\\n function __Ownable2Step_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable2Step_init_unchained() internal onlyInitializing {\\n }\\n address private _pendingOwner;\\n\\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Returns the address of the pending owner.\\n */\\n function pendingOwner() public view virtual returns (address) {\\n return _pendingOwner;\\n }\\n\\n /**\\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual override onlyOwner {\\n _pendingOwner = newOwner;\\n emit OwnershipTransferStarted(owner(), newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual override {\\n delete _pendingOwner;\\n super._transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev The new owner accepts the ownership transfer.\\n */\\n function acceptOwnership() public virtual {\\n address sender = _msgSender();\\n require(pendingOwner() == sender, \\\"Ownable2Step: caller is not the new owner\\\");\\n _transferOwnership(sender);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x84efb8889801b0ac817324aff6acc691d07bbee816b671817132911d287a8c63\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n function __Ownable_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable_init_unchained() internal onlyInitializing {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby disabling any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x4075622496acc77fd6d4de4cc30a8577a744d5c75afad33fdeacf1704d6eda98\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts.\\n *\\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n * constructor.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n * are added through upgrades and that require initialization.\\n *\\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n * cannot be nested. If one is invoked in the context of another, execution will revert.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n *\\n * WARNING: setting the version to 255 will prevent any future reinitialization.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n *\\n * Emits an {Initialized} event the first time it is successfully executed.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized != type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n\\n /**\\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n */\\n function _getInitializedVersion() internal view returns (uint8) {\\n return _initialized;\\n }\\n\\n /**\\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n */\\n function _isInitializing() internal view returns (bool) {\\n return _initializing;\\n }\\n}\\n\",\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state.\\n */\\n function __Pausable_init() internal onlyInitializing {\\n __Pausable_init_unchained();\\n }\\n\\n function __Pausable_init_unchained() internal onlyInitializing {\\n _paused = false;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused() {\\n _requireNotPaused();\\n _;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier whenPaused() {\\n _requirePaused();\\n _;\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused() public view virtual returns (bool) {\\n return _paused;\\n }\\n\\n /**\\n * @dev Throws if the contract is paused.\\n */\\n function _requireNotPaused() internal view virtual {\\n require(!paused(), \\\"Pausable: paused\\\");\\n }\\n\\n /**\\n * @dev Throws if the contract is not paused.\\n */\\n function _requirePaused() internal view virtual {\\n require(paused(), \\\"Pausable: not paused\\\");\\n }\\n\\n /**\\n * @dev Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(_msgSender());\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n function __ReentrancyGuard_init() internal onlyInitializing {\\n __ReentrancyGuard_init_unchained();\\n }\\n\\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == _ENTERED;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xb82ef33f43b6b96109687d91b39c94573fdccaaa423fe28e8ba0977b31c023e0\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20PermitUpgradeable {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xd60f939a3ca0199014d079b4dd66aa757954334947d81eb5c1d35d7a83061ab3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\nimport \\\"../extensions/IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20Upgradeable {\\n using AddressUpgradeable for address;\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\\n * Revert on invalid signature.\\n */\\n function safePermit(\\n IERC20PermitUpgradeable token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return\\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));\\n }\\n}\\n\",\"keccak256\":\"0x23b997be73d3dd46885262704f0f8cfc7273fdadfe303d37969a9561373972b5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n *\\n * Furthermore, `isContract` will also return true if the target contract within\\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n * which only has an effect at the end of a transaction.\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal onlyInitializing {\\n }\\n\\n function __Context_init_unchained() internal onlyInitializing {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl {\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\"},\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\\\";\\n\\nimport \\\"./IAccessControlManagerV8.sol\\\";\\n\\n/**\\n * @title AccessControlledV8\\n * @author Venus\\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.8.13)\\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\\n */\\nabstract contract AccessControlledV8 is Initializable, Ownable2StepUpgradeable {\\n /// @notice Access control manager contract\\n IAccessControlManagerV8 private _accessControlManager;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n\\n /// @notice Emitted when access control manager contract address is changed\\n event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\\n\\n /// @notice Thrown when the action is prohibited by AccessControlManager\\n error Unauthorized(address sender, address calledContract, string methodSignature);\\n\\n function __AccessControlled_init(address accessControlManager_) internal onlyInitializing {\\n __Ownable2Step_init();\\n __AccessControlled_init_unchained(accessControlManager_);\\n }\\n\\n function __AccessControlled_init_unchained(address accessControlManager_) internal onlyInitializing {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Sets the address of AccessControlManager\\n * @dev Admin function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n * @custom:event Emits NewAccessControlManager event\\n * @custom:access Only Governance\\n */\\n function setAccessControlManager(address accessControlManager_) external onlyOwner {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Returns the address of the access control manager contract\\n */\\n function accessControlManager() external view returns (IAccessControlManagerV8) {\\n return _accessControlManager;\\n }\\n\\n /**\\n * @dev Internal function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n */\\n function _setAccessControlManager(address accessControlManager_) internal {\\n require(address(accessControlManager_) != address(0), \\\"invalid acess control manager address\\\");\\n address oldAccessControlManager = address(_accessControlManager);\\n _accessControlManager = IAccessControlManagerV8(accessControlManager_);\\n emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\\n }\\n\\n /**\\n * @notice Reverts if the call is not allowed by AccessControlManager\\n * @param signature Method signature\\n */\\n function _checkAccessAllowed(string memory signature) internal view {\\n bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\\n\\n if (!isAllowedToCall) {\\n revert Unauthorized(msg.sender, address(this), signature);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0dcf283925f4dddc23ca0ee71d2cb96a9dd6e4cf08061b69fde1697ea39dc514\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/access/IAccessControl.sol\\\";\\n\\n/**\\n * @title IAccessControlManagerV8\\n * @author Venus\\n * @notice Interface implemented by the `AccessControlManagerV8` contract.\\n */\\ninterface IAccessControlManagerV8 is IAccessControl {\\n function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\\n\\n function revokeCallPermission(\\n address contractAddress,\\n string calldata functionSig,\\n address accountToRevoke\\n ) external;\\n\\n function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\\n\\n function hasPermission(\\n address account,\\n address contractAddress,\\n string calldata functionSig\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xaa29b098440d0b3a131c5ecdf25ce548790c1b5ac7bf9b5c0264b6af6f7a1e0b\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/ResilientOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\n// SPDX-FileCopyrightText: 2022 Venus\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\nimport \\\"./interfaces/VBep20Interface.sol\\\";\\nimport \\\"./interfaces/OracleInterface.sol\\\";\\nimport \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\n\\n/**\\n * @title ResilientOracle\\n * @author Venus\\n * @notice The Resilient Oracle is the main contract that the protocol uses to fetch prices of assets.\\n *\\n * DeFi protocols are vulnerable to price oracle failures including oracle manipulation and incorrectly\\n * reported prices. If only one oracle is used, this creates a single point of failure and opens a vector\\n * for attacking the protocol.\\n *\\n * The Resilient Oracle uses multiple sources and fallback mechanisms to provide accurate prices and protect\\n * the protocol from oracle attacks. Currently it includes integrations with Chainlink, Pyth, Binance Oracle\\n * and TWAP (Time-Weighted Average Price) oracles. TWAP uses PancakeSwap as the on-chain price source.\\n *\\n * For every market (vToken) we configure the main, pivot and fallback oracles. The oracles are configured per\\n * vToken's underlying asset address. The main oracle oracle is the most trustworthy price source, the pivot\\n * oracle is used as a loose sanity checker and the fallback oracle is used as a backup price source.\\n *\\n * To validate prices returned from two oracles, we use an upper and lower bound ratio that is set for every\\n * market. The upper bound ratio represents the deviation between reported price (the price that\\u2019s being\\n * validated) and the anchor price (the price we are validating against) above which the reported price will\\n * be invalidated. The lower bound ratio presents the deviation between reported price and anchor price below\\n * which the reported price will be invalidated. So for oracle price to be considered valid the below statement\\n * should be true:\\n\\n```\\nanchorRatio = anchorPrice/reporterPrice\\nisValid = anchorRatio <= upperBoundAnchorRatio && anchorRatio >= lowerBoundAnchorRatio\\n```\\n\\n * In most cases, Chainlink is used as the main oracle, TWAP or Pyth oracles are used as the pivot oracle depending\\n * on which supports the given market and Binance oracle is used as the fallback oracle. For some markets we may\\n * use Pyth or TWAP as the main oracle if the token price is not supported by Chainlink or Binance oracles.\\n *\\n * For a fetched price to be valid it must be positive and not stagnant. If the price is invalid then we consider the\\n * oracle to be stagnant and treat it like it's disabled.\\n */\\ncontract ResilientOracle is PausableUpgradeable, AccessControlledV8, ResilientOracleInterface {\\n /**\\n * @dev Oracle roles:\\n * **main**: The most trustworthy price source\\n * **pivot**: Price oracle used as a loose sanity checker\\n * **fallback**: The backup source when main oracle price is invalidated\\n */\\n enum OracleRole {\\n MAIN,\\n PIVOT,\\n FALLBACK\\n }\\n\\n struct TokenConfig {\\n /// @notice asset address\\n address asset;\\n /// @notice `oracles` stores the oracles based on their role in the following order:\\n /// [main, pivot, fallback],\\n /// It can be indexed with the corresponding enum OracleRole value\\n address[3] oracles;\\n /// @notice `enableFlagsForOracles` stores the enabled state\\n /// for each oracle in the same order as `oracles`\\n bool[3] enableFlagsForOracles;\\n }\\n\\n uint256 public constant INVALID_PRICE = 0;\\n\\n /// @notice Native market address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable nativeMarket;\\n\\n /// @notice VAI address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable vai;\\n\\n /// @notice Set this as asset address for Native token on each chain.This is the underlying for vBNB (on bsc)\\n /// and can serve as any underlying asset of a market that supports native tokens\\n address public constant NATIVE_TOKEN_ADDR = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\\n\\n /// @notice Bound validator contract address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n BoundValidatorInterface public immutable boundValidator;\\n\\n mapping(address => TokenConfig) private tokenConfigs;\\n\\n event TokenConfigAdded(\\n address indexed asset,\\n address indexed mainOracle,\\n address indexed pivotOracle,\\n address fallbackOracle\\n );\\n\\n /// Event emitted when an oracle is set\\n event OracleSet(address indexed asset, address indexed oracle, uint256 indexed role);\\n\\n /// Event emitted when an oracle is enabled or disabled\\n event OracleEnabled(address indexed asset, uint256 indexed role, bool indexed enable);\\n\\n /**\\n * @notice Checks whether an address is null or not\\n */\\n modifier notNullAddress(address someone) {\\n if (someone == address(0)) revert(\\\"can't be zero address\\\");\\n _;\\n }\\n\\n /**\\n * @notice Checks whether token config exists by checking whether asset is null address\\n * @dev address can't be null, so it's suitable to be used to check the validity of the config\\n * @param asset asset address\\n */\\n modifier checkTokenConfigExistence(address asset) {\\n if (tokenConfigs[asset].asset == address(0)) revert(\\\"token config must exist\\\");\\n _;\\n }\\n\\n /// @notice Constructor for the implementation contract. Sets immutable variables.\\n /// @dev nativeMarketAddress can be address(0) if on the chain we do not support native market\\n /// (e.g vETH on ethereum would not be supported, only vWETH)\\n /// @param nativeMarketAddress The address of a native market (for bsc it would be vBNB address)\\n /// @param vaiAddress The address of the VAI token (if there is VAI on the deployed chain).\\n /// Set to address(0) of VAI is not existent.\\n /// @param _boundValidator Address of the bound validator contract\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor(\\n address nativeMarketAddress,\\n address vaiAddress,\\n BoundValidatorInterface _boundValidator\\n ) notNullAddress(address(_boundValidator)) {\\n nativeMarket = nativeMarketAddress;\\n vai = vaiAddress;\\n boundValidator = _boundValidator;\\n\\n _disableInitializers();\\n }\\n\\n /**\\n * @notice Initializes the contract admin and sets the BoundValidator contract address\\n * @param accessControlManager_ Address of the access control manager contract\\n */\\n function initialize(address accessControlManager_) external initializer {\\n __AccessControlled_init(accessControlManager_);\\n __Pausable_init();\\n }\\n\\n /**\\n * @notice Pauses oracle\\n * @custom:access Only Governance\\n */\\n function pause() external {\\n _checkAccessAllowed(\\\"pause()\\\");\\n _pause();\\n }\\n\\n /**\\n * @notice Unpauses oracle\\n * @custom:access Only Governance\\n */\\n function unpause() external {\\n _checkAccessAllowed(\\\"unpause()\\\");\\n _unpause();\\n }\\n\\n /**\\n * @notice Batch sets token configs\\n * @param tokenConfigs_ Token config array\\n * @custom:access Only Governance\\n * @custom:error Throws a length error if the length of the token configs array is 0\\n */\\n function setTokenConfigs(TokenConfig[] memory tokenConfigs_) external {\\n if (tokenConfigs_.length == 0) revert(\\\"length can't be 0\\\");\\n uint256 numTokenConfigs = tokenConfigs_.length;\\n for (uint256 i; i < numTokenConfigs; ) {\\n setTokenConfig(tokenConfigs_[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /**\\n * @notice Sets oracle for a given asset and role.\\n * @dev Supplied asset **must** exist and main oracle may not be null\\n * @param asset Asset address\\n * @param oracle Oracle address\\n * @param role Oracle role\\n * @custom:access Only Governance\\n * @custom:error Null address error if main-role oracle address is null\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n * @custom:event Emits OracleSet event with asset address, oracle address and role of the oracle for the asset\\n */\\n function setOracle(\\n address asset,\\n address oracle,\\n OracleRole role\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"setOracle(address,address,uint8)\\\");\\n if (oracle == address(0) && role == OracleRole.MAIN) revert(\\\"can't set zero address to main oracle\\\");\\n tokenConfigs[asset].oracles[uint256(role)] = oracle;\\n emit OracleSet(asset, oracle, uint256(role));\\n }\\n\\n /**\\n * @notice Enables/ disables oracle for the input asset. Token config for the input asset **must** exist\\n * @dev Configuration for the asset **must** already exist and the asset cannot be 0 address\\n * @param asset Asset address\\n * @param role Oracle role\\n * @param enable Enabled boolean of the oracle\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n */\\n function enableOracle(\\n address asset,\\n OracleRole role,\\n bool enable\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"enableOracle(address,uint8,bool)\\\");\\n tokenConfigs[asset].enableFlagsForOracles[uint256(role)] = enable;\\n emit OracleEnabled(asset, uint256(role), enable);\\n }\\n\\n /**\\n * @notice Updates the TWAP pivot oracle price.\\n * @dev This function should always be called before calling getUnderlyingPrice\\n * @param vToken vToken address\\n */\\n function updatePrice(address vToken) external override {\\n address asset = _getUnderlyingAsset(vToken);\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @notice Updates the pivot oracle price. Currently using TWAP\\n * @dev This function should always be called before calling getPrice\\n * @param asset asset address\\n */\\n function updateAssetPrice(address asset) external {\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @dev Gets token config by asset address\\n * @param asset asset address\\n * @return tokenConfig Config for the asset\\n */\\n function getTokenConfig(address asset) external view returns (TokenConfig memory) {\\n return tokenConfigs[asset];\\n }\\n\\n /**\\n * @notice Gets price of the underlying asset for a given vToken. Validation flow:\\n * - Check if the oracle is paused globally\\n * - Validate price from main oracle against pivot oracle\\n * - Validate price from fallback oracle against pivot oracle if the first validation failed\\n * - Validate price from main oracle against fallback oracle if the second validation failed\\n * In the case that the pivot oracle is not available but main price is available and validation is successful,\\n * main oracle price is returned.\\n * @param vToken vToken address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getUnderlyingPrice(address vToken) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n\\n address asset = _getUnderlyingAsset(vToken);\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Gets price of the asset\\n * @param asset asset address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getPrice(address asset) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Sets/resets single token configs.\\n * @dev main oracle **must not** be a null address\\n * @param tokenConfig Token config struct\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress is thrown if asset address is null\\n * @custom:error NotNullAddress is thrown if main-role oracle address for asset is null\\n * @custom:event Emits TokenConfigAdded event when the asset config is set successfully by the authorized account\\n */\\n function setTokenConfig(\\n TokenConfig memory tokenConfig\\n ) public notNullAddress(tokenConfig.asset) notNullAddress(tokenConfig.oracles[uint256(OracleRole.MAIN)]) {\\n _checkAccessAllowed(\\\"setTokenConfig(TokenConfig)\\\");\\n\\n tokenConfigs[tokenConfig.asset] = tokenConfig;\\n emit TokenConfigAdded(\\n tokenConfig.asset,\\n tokenConfig.oracles[uint256(OracleRole.MAIN)],\\n tokenConfig.oracles[uint256(OracleRole.PIVOT)],\\n tokenConfig.oracles[uint256(OracleRole.FALLBACK)]\\n );\\n }\\n\\n /**\\n * @notice Gets oracle and enabled status by asset address\\n * @param asset asset address\\n * @param role Oracle role\\n * @return oracle Oracle address based on role\\n * @return enabled Enabled flag of the oracle based on token config\\n */\\n function getOracle(address asset, OracleRole role) public view returns (address oracle, bool enabled) {\\n oracle = tokenConfigs[asset].oracles[uint256(role)];\\n enabled = tokenConfigs[asset].enableFlagsForOracles[uint256(role)];\\n }\\n\\n function _getPrice(address asset) internal view returns (uint256) {\\n uint256 pivotPrice = INVALID_PRICE;\\n\\n // Get pivot oracle price, Invalid price if not available or error\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracleEnabled && pivotOracle != address(0)) {\\n try OracleInterface(pivotOracle).getPrice(asset) returns (uint256 pricePivot) {\\n pivotPrice = pricePivot;\\n } catch {}\\n }\\n\\n // Compare main price and pivot price, return main price and if validation was successful\\n // note: In case pivot oracle is not available but main price is available and\\n // validation is successful, the main oracle price is returned.\\n (uint256 mainPrice, bool validatedPivotMain) = _getMainOraclePrice(\\n asset,\\n pivotPrice,\\n pivotOracleEnabled && pivotOracle != address(0)\\n );\\n if (mainPrice != INVALID_PRICE && validatedPivotMain) return mainPrice;\\n\\n // Compare fallback and pivot if main oracle comparision fails with pivot\\n // Return fallback price when fallback price is validated successfully with pivot oracle\\n (uint256 fallbackPrice, bool validatedPivotFallback) = _getFallbackOraclePrice(asset, pivotPrice);\\n if (fallbackPrice != INVALID_PRICE && validatedPivotFallback) return fallbackPrice;\\n\\n // Lastly compare main price and fallback price\\n if (\\n mainPrice != INVALID_PRICE &&\\n fallbackPrice != INVALID_PRICE &&\\n boundValidator.validatePriceWithAnchorPrice(asset, mainPrice, fallbackPrice)\\n ) {\\n return mainPrice;\\n }\\n\\n revert(\\\"invalid resilient oracle price\\\");\\n }\\n\\n /**\\n * @notice Gets a price for the provided asset\\n * @dev This function won't revert when price is 0, because the fallback oracle may still be\\n * able to fetch a correct price\\n * @param asset asset address\\n * @param pivotPrice Pivot oracle price\\n * @param pivotEnabled If pivot oracle is not empty and enabled\\n * @return price USD price in scaled decimals\\n * e.g. asset decimals is 8 then price is returned as 10**18 * 10**(18-8) = 10**28 decimals\\n * @return pivotValidated Boolean representing if the validation of main oracle price\\n * and pivot oracle price were successful\\n * @custom:error Invalid price error is thrown if main oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if main oracle is not enabled or main oracle\\n * address is null\\n */\\n function _getMainOraclePrice(\\n address asset,\\n uint256 pivotPrice,\\n bool pivotEnabled\\n ) internal view returns (uint256, bool) {\\n (address mainOracle, bool mainOracleEnabled) = getOracle(asset, OracleRole.MAIN);\\n if (mainOracleEnabled && mainOracle != address(0)) {\\n try OracleInterface(mainOracle).getPrice(asset) returns (uint256 mainOraclePrice) {\\n if (!pivotEnabled) {\\n return (mainOraclePrice, true);\\n }\\n if (pivotPrice == INVALID_PRICE) {\\n return (mainOraclePrice, false);\\n }\\n return (\\n mainOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, mainOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function won't revert when the price is 0 because getPrice checks if price is > 0\\n * @param asset asset address\\n * @return price USD price in 18 decimals\\n * @return pivotValidated Boolean representing if the validation of fallback oracle price\\n * and pivot oracle price were successfully\\n * @custom:error Invalid price error is thrown if fallback oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if fallback oracle is not enabled or fallback oracle\\n * address is null\\n */\\n function _getFallbackOraclePrice(address asset, uint256 pivotPrice) private view returns (uint256, bool) {\\n (address fallbackOracle, bool fallbackEnabled) = getOracle(asset, OracleRole.FALLBACK);\\n if (fallbackEnabled && fallbackOracle != address(0)) {\\n try OracleInterface(fallbackOracle).getPrice(asset) returns (uint256 fallbackOraclePrice) {\\n if (pivotPrice == INVALID_PRICE) {\\n return (fallbackOraclePrice, false);\\n }\\n return (\\n fallbackOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, fallbackOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function returns the underlying asset of a vToken\\n * @param vToken vToken address\\n * @return asset underlying asset address\\n */\\n function _getUnderlyingAsset(address vToken) private view notNullAddress(vToken) returns (address asset) {\\n if (vToken == nativeMarket) {\\n asset = NATIVE_TOKEN_ADDR;\\n } else if (vToken == vai) {\\n asset = vai;\\n } else {\\n asset = VBep20Interface(vToken).underlying();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xdaaa90daa8ca5bda477729aaa5d5ff3e5305635baec1799a368d564ae2a13c4c\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\ninterface OracleInterface {\\n function getPrice(address asset) external view returns (uint256);\\n}\\n\\ninterface ResilientOracleInterface is OracleInterface {\\n function updatePrice(address vToken) external;\\n\\n function updateAssetPrice(address asset) external;\\n\\n function getUnderlyingPrice(address vToken) external view returns (uint256);\\n}\\n\\ninterface TwapInterface is OracleInterface {\\n function updateTwap(address asset) external returns (uint256);\\n}\\n\\ninterface BoundValidatorInterface {\\n function validatePriceWithAnchorPrice(\\n address asset,\\n uint256 reporterPrice,\\n uint256 anchorPrice\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x2432799b0d824fc701beb4c30146e912b9aeecf77b5c1635dde6c5fbe6bfc3a7\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/VBep20Interface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\ninterface VBep20Interface is IERC20Metadata {\\n /**\\n * @notice Underlying asset for this VToken\\n */\\n function underlying() external view returns (address);\\n}\\n\",\"keccak256\":\"0x6e71c3df86501df5c0e4bace1333c0c91f9f9cced252a54fb99eeda219b789d5\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/constants.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\n/// @dev Base unit for computations, usually used in scaling (multiplications, divisions)\\nuint256 constant EXP_SCALE = 1e18;\\n\\n/// @dev A unit (literal one) in EXP_SCALE, usually used in additions/subtractions\\nuint256 constant MANTISSA_ONE = EXP_SCALE;\\n\\n/// @dev The approximate number of seconds per year\\nuint256 constant SECONDS_PER_YEAR = 31_536_000;\\n\",\"keccak256\":\"0x14de93ead464da249af31bea0e3bcfb62ec693bea3475fb4d90f055ac81dc5eb\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/validators.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\n/// @notice Thrown if the supplied address is a zero address where it is not allowed\\nerror ZeroAddressNotAllowed();\\n\\n/// @notice Thrown if the supplied value is 0 where it is not allowed\\nerror ZeroValueNotAllowed();\\n\\n/// @notice Checks if the provided address is nonzero, reverts otherwise\\n/// @param address_ Address to check\\n/// @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address\\nfunction ensureNonzeroAddress(address address_) pure {\\n if (address_ == address(0)) {\\n revert ZeroAddressNotAllowed();\\n }\\n}\\n\\n/// @notice Checks if the provided value is nonzero, reverts otherwise\\n/// @param value_ Value to check\\n/// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\nfunction ensureNonzeroValue(uint256 value_) pure {\\n if (value_ == 0) {\\n revert ZeroValueNotAllowed();\\n }\\n}\\n\",\"keccak256\":\"0xdb88e14d50dd21889ca3329d755673d022c47e8da005b6a545c7f69c2c4b7b86\",\"license\":\"BSD-3-Clause\"},\"contracts/Interfaces/IConverterNetwork.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { IAbstractTokenConverter } from \\\"../TokenConverter/IAbstractTokenConverter.sol\\\";\\n\\n/**\\n * @title IConverterNetwork\\n * @author Venus\\n * @notice Interface implemented by `ConverterNetwork`.\\n */\\ninterface IConverterNetwork {\\n /// @notice Adds new converter to the array\\n /// @param _tokenConverter Address of the token converter\\n function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Removes converter from the array\\n /// @param _tokenConverter Address of the token converter\\n function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice This function returns the array containing all the converters addresses\\n /// @return Array containing all the converters addresses\\n function getAllConverters() external view returns (IAbstractTokenConverter[] memory);\\n\\n /// @notice This function checks for given address is converter or not\\n /// @param _tokenConverter Address of the token converter\\n /// @return boolean true if given address is converter otherwise false\\n function isTokenConverter(address _tokenConverter) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xd9a747f176d9b9de220331b87ed711cc2bd594a118b538a35f3c47060bff7a8b\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/AbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { ReentrancyGuardUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { AccessControlledV8 } from \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress, ensureNonzeroValue } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\nimport { MANTISSA_ONE, EXP_SCALE } from \\\"@venusprotocol/solidity-utilities/contracts/constants.sol\\\";\\n\\nimport { IAbstractTokenConverter } from \\\"./IAbstractTokenConverter.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @title AbstractTokenConverter\\n/// @author Venus\\n/// @notice Abstract contract will be extended by SingleTokenConverter and RiskFundConverter\\n/*\\n * This contract specifies four functions for converting tokens, each applicable under following circumstances:\\n *\\n * Case I: TokenIn -> deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions supporting fees can only be utilized to convert tokens which are:\\n * a. convertExactTokensSupportingFeeOnTransferTokens\\n * b. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case II: TokenIn -> deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions supporting fee can only be utilized to convert tokens which are:\\n * similar to Case I.\\n *\\n * Case III: TokenIn -> non-deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * a. convertExactTokens\\n * b. convertForExactTokens\\n * c. convertExactTokensSupportingFeeOnTransferTokens\\n * d. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case IV: TokenIn -> non-deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * similar to Case III.\\n *\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n * Example 1:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInAmount - 100\\n * tokenOutMinAmount - minimum amount desired by the user(let's say 70)\\n * Here user can use `convertExactTokens` or `convertExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertExactTokens` is used).\\n * Now first tokenInAddress tokens will be transferred from the user to the contract, on the basis of amount\\n * received(as tokenInAddress can be deflationary token) tokenAmountOut will be calculated and will be transferred\\n * to the user and if amount sent is less than tokenOutMinAmount, tx will revert. If amount sent is satisfied(let's say\\n * 80 or even 70) then at last the actual amount received and the amount that was supposed to be received by the contract will\\n * be compared, if they differ then the whole tx will revert as user was supposed to use `convertExactTokensSupportingFeeOnTransferTokens`\\n * function for tokenIn as deflationary token.\\n *\\n * Example 2:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInMaxAmount - maximum amount user is willing to provide(let's say 100)\\n * tokenOutAmount - 70\\n * Here user can use `convertForExactTokens` or `convertForExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertForExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertForExactTokens` is used),\\n * which on the basis of tokenOutAmount provided will calculate tokenInAmount based on the tokens prices and will transfer\\n * tokens from the user to the contract, now the actual amount received(as tokenInAddress can be deflationary token) will be\\n * compared with tokenInMaxAmount if it is greater, tx will revert. If In amount is satisfied(let's say 90 or even 100) then\\n * new tokenOutAmount will be calculated, and tokenOutAddress tokens will be transferred to the user, but at last the\\n * old tokenOutAmount and new tokenOutAmount will be compared and if they differ whole tx will revert, because user was\\n * supposed to use `convertForExactTokensSupportingFeeOnTransferTokens` function for tokenIn as deflationary token.\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n *\\n * This contract also supports private conversion between the converters:\\n * Private conversions:\\n * Private conversions is designed in order to convert the maximum amount of tokens received from PSR(to any converter) between\\n * existing converters to save incentive and lower the dependency of users for conversion. So Private Conversion will be executed\\n * by converters on it's own whenever funds are received from PSR. No incentive will be offered during private conversion.\\n *\\n * It will execute on updateAssetsState() function call in Converter Contracts. After this function call, converter will first\\n * check for the amount received. If base asset is received then it will be directly sent to the destination address and no private\\n * conversion will happen otherwise converter will interact with ConverterNetwork contract to find other valid converters who are providing the conversion for:\\n *\\n * tokenAddressIn: As asset received by that converter on updateAssetsState() function call.\\n * tokenAddressOut: As base asset of that converter.\\n *\\n * ConverterNetwork:\\n * This contract will contain all the converters, and will provide valid converters which can perform the execution according to tokenAddressIn\\n * and tokenAddressOut provided.\\n *\\n * findTokenConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for users).\\n *\\n * findTokenConvertersForConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for converters).\\n */\\n\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\nabstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenConverter, ReentrancyGuardUpgradeable {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Maximum incentive could be\\n uint256 public constant MAX_INCENTIVE = 0.5e18;\\n\\n /// @notice Min amount to convert for private conversions. Defined in USD, with 18 decimals\\n uint256 public minAmountToConvert;\\n\\n /// @notice Venus price oracle contract\\n ResilientOracle public priceOracle;\\n\\n /// @notice conversion configurations for the existing pairs\\n /// @dev tokenAddressIn => tokenAddressOut => ConversionConfig\\n mapping(address => mapping(address => ConversionConfig)) public conversionConfigurations;\\n\\n /// @notice Address that all incoming tokens are transferred to\\n address public destinationAddress;\\n\\n /// @notice Boolean for if conversion is paused\\n bool public conversionPaused;\\n\\n /// @notice Address of the converterNetwork contract\\n IConverterNetwork public converterNetwork;\\n\\n /// @dev This empty reserved space is put in place to allow future versions to add new\\n /// variables without shifting down storage in the inheritance chain.\\n /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n uint256[45] private __gap;\\n\\n /// @notice Emitted when config is updated for tokens pair\\n event ConversionConfigUpdated(\\n address indexed tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 oldIncentive,\\n uint256 newIncentive,\\n ConversionAccessibility oldAccess,\\n ConversionAccessibility newAccess\\n );\\n /// @notice Emitted when price oracle address is updated\\n event PriceOracleUpdated(ResilientOracle indexed oldPriceOracle, ResilientOracle indexed priceOracle);\\n\\n /// @notice Emitted when destination address is updated\\n event DestinationAddressUpdated(address indexed oldDestinationAddress, address indexed destinationAddress);\\n\\n /// @notice Emitted when converterNetwork address is updated\\n event ConverterNetworkAddressUpdated(address indexed oldConverterNetwork, address indexed converterNetwork);\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens\\n event ConvertedExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens\\n event ConvertedForExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\\n event ConvertedExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\\n event ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when conversion is paused\\n event ConversionPaused(address indexed sender);\\n\\n /// @notice Emitted when conversion is unpaused\\n event ConversionResumed(address indexed sender);\\n\\n /// @notice Event emitted when tokens are swept\\n event SweepToken(address indexed token, address indexed to, uint256 amount);\\n\\n /// @notice Emitted when minimum amount to convert is updated\\n event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);\\n\\n /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\\n error AmountOutMismatched();\\n\\n /// @notice Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\\n error AmountInMismatched();\\n\\n /// @notice Thrown when given input amount is zero\\n error InsufficientInputAmount();\\n\\n /// @notice Thrown when given output amount is zero\\n error InsufficientOutputAmount();\\n\\n /// @notice Thrown when conversion is disabled or config does not exist for given pair\\n error ConversionConfigNotEnabled();\\n\\n /// @notice Thrown when conversion is enabled only for private conversions\\n error ConversionEnabledOnlyForPrivateConversions();\\n\\n /// @notice Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n error InvalidToAddress();\\n\\n /// @notice Thrown when incentive is higher than the MAX_INCENTIVE\\n error IncentiveTooHigh(uint256 incentive, uint256 maxIncentive);\\n\\n /// @notice Thrown when amountOut is lower than amountOutMin\\n error AmountOutLowerThanMinRequired(uint256 amountOutMantissa, uint256 amountOutMinMantissa);\\n\\n /// @notice Thrown when amountIn is higher than amountInMax\\n error AmountInHigherThanMax(uint256 amountInMantissa, uint256 amountInMaxMantissa);\\n\\n /// @notice Thrown when conversion is paused\\n error ConversionTokensPaused();\\n\\n /// @notice Thrown when conversion is Active\\n error ConversionTokensActive();\\n\\n /// @notice Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\\n error InvalidTokenConfigAddresses();\\n\\n /// @notice Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\\n error InsufficientPoolLiquidity();\\n\\n /// @notice When address of the ConverterNetwork is not set or Zero address\\n error InvalidConverterNetwork();\\n\\n /// @notice Thrown when trying to set non zero incentive for private conversion\\n error NonZeroIncentiveForPrivateConversion();\\n\\n /// @notice Thrown when using convertForExactTokens deflationary tokens\\n error DeflationaryTokenNotSupported();\\n\\n /// @notice Thrown when minimum amount to convert is zero\\n error InvalidMinimumAmountToConvert();\\n\\n /// @notice Thrown when there is a mismatch in the length of input arrays\\n error InputLengthMisMatch();\\n\\n /**\\n * @notice Modifier to ensure valid conversion parameters for a token conversion\\n * and check if conversion is paused or not\\n * @param to The recipient address for the converted tokens\\n * @param tokenAddressIn The input token address for the conversion\\n * @param tokenAddressOut The output token address for the conversion\\n */\\n modifier validConversionParameters(\\n address to,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) {\\n _checkConversionPaused();\\n ensureNonzeroAddress(to);\\n if (to == tokenAddressIn || to == tokenAddressOut) {\\n revert InvalidToAddress();\\n }\\n _;\\n }\\n\\n /// @notice Pause conversion of tokens\\n /// @custom:event Emits ConversionPaused on success\\n /// @custom:error ConversionTokensPaused thrown when conversion is already paused\\n /// @custom:access Restricted by ACM\\n function pauseConversion() external {\\n _checkAccessAllowed(\\\"pauseConversion()\\\");\\n _checkConversionPaused();\\n conversionPaused = true;\\n emit ConversionPaused(msg.sender);\\n }\\n\\n /// @notice Resume conversion of tokens.\\n /// @custom:event Emits ConversionResumed on success\\n /// @custom:error ConversionTokensActive thrown when conversion is already active\\n /// @custom:access Restricted by ACM\\n function resumeConversion() external {\\n _checkAccessAllowed(\\\"resumeConversion()\\\");\\n if (!conversionPaused) {\\n revert ConversionTokensActive();\\n }\\n\\n conversionPaused = false;\\n emit ConversionResumed(msg.sender);\\n }\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:access Only Governance\\n function setPriceOracle(ResilientOracle priceOracle_) external onlyOwner {\\n _setPriceOracle(priceOracle_);\\n }\\n\\n /// @notice Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:access Only Governance\\n function setDestination(address destinationAddress_) external onlyOwner {\\n _setDestination(destinationAddress_);\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:access Only Governance\\n function setConverterNetwork(IConverterNetwork converterNetwork_) external onlyOwner {\\n _setConverterNetwork(converterNetwork_);\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:access Only Governance\\n function setMinAmountToConvert(uint256 minAmountToConvert_) external {\\n _checkAccessAllowed(\\\"setMinAmountToConvert(uint256)\\\");\\n _setMinAmountToConvert(minAmountToConvert_);\\n }\\n\\n /// @notice Batch sets the conversion configurations\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressesOut Array of addresses of tokenOut\\n /// @param conversionConfigs Array of conversionConfig config details to update\\n /// @custom:error InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\\n function setConversionConfigs(\\n address tokenAddressIn,\\n address[] calldata tokenAddressesOut,\\n ConversionConfig[] calldata conversionConfigs\\n ) external {\\n uint256 tokenOutArrayLength = tokenAddressesOut.length;\\n if (tokenOutArrayLength != conversionConfigs.length) revert InputLengthMisMatch();\\n\\n for (uint256 i; i < tokenOutArrayLength; ) {\\n setConversionConfig(tokenAddressIn, tokenAddressesOut[i], conversionConfigs[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n /// @custom:error AmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert AmountInMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract,\\n /// otherwise the amount is adjusted\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n /// @custom:error AmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountOut != amountOutMantissa) {\\n revert AmountOutMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of\\n /// tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted.\\n /// The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokensSupportingFeeOnTransferTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice To sweep ERC20 tokens and transfer them to user(to address)\\n /// @param tokenAddress The address of the ERC-20 token to sweep\\n /// @param to The address to which tokens will be transferred\\n /// @param amount The amount to transfer\\n /// @custom:event Emits SweepToken event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\\n /// @custom:access Only Governance\\n function sweepToken(\\n address tokenAddress,\\n address to,\\n uint256 amount\\n ) external onlyOwner nonReentrant {\\n ensureNonzeroAddress(tokenAddress);\\n ensureNonzeroAddress(to);\\n ensureNonzeroValue(amount);\\n\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n preSweepToken(tokenAddress, amount);\\n token.safeTransfer(to, amount);\\n\\n emit SweepToken(tokenAddress, to, amount);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @notice The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n amountConvertedMantissa = amountInMantissa;\\n uint256 tokenInToOutConversion;\\n (amountOutMantissa, tokenInToOutConversion) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountConvertedMantissa = _divRoundingUp(maxTokenOutReserve * EXP_SCALE, tokenInToOutConversion);\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n\\n amountConvertedMantissa = amountOutMantissa;\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountOutMantissa, ) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountInMantissa;\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountOutMantissa;\\n }\\n\\n /// @notice This method updated the states of this contract after getting funds from PSR\\n /// after settling the amount(if any) through privateConversion between converters\\n /// @dev This function is called by protocolShareReserve\\n /// @dev call _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then\\n /// it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n function updateAssetsState(address comptroller, address asset) public nonReentrant {\\n uint256 balanceDiff = _updateAssetsState(comptroller, asset);\\n if (balanceDiff > 0) {\\n _privateConversion(comptroller, asset, balanceDiff);\\n }\\n }\\n\\n /// @notice Set the configuration for new or existing conversion pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n /// @custom:event Emits ConversionConfigUpdated event on success\\n /// @custom:error Unauthorized error is thrown when the call is not authorized by AccessControlManager\\n /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero\\n /// @custom:error NonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\\n /// @custom:access Controlled by AccessControlManager\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) public {\\n _checkAccessAllowed(\\\"setConversionConfig(address,address,ConversionConfig)\\\");\\n ensureNonzeroAddress(tokenAddressIn);\\n ensureNonzeroAddress(tokenAddressOut);\\n\\n if (conversionConfig.incentive > MAX_INCENTIVE) {\\n revert IncentiveTooHigh(conversionConfig.incentive, MAX_INCENTIVE);\\n }\\n\\n if (\\n (tokenAddressIn == tokenAddressOut) ||\\n (tokenAddressIn != _getDestinationBaseAsset()) ||\\n conversionConfigurations[tokenAddressOut][tokenAddressIn].conversionAccess != ConversionAccessibility.NONE\\n ) {\\n revert InvalidTokenConfigAddresses();\\n }\\n\\n if (\\n (conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) &&\\n conversionConfig.incentive != 0\\n ) {\\n revert NonZeroIncentiveForPrivateConversion();\\n }\\n\\n if (\\n ((conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) ||\\n (conversionConfig.conversionAccess == ConversionAccessibility.ALL)) &&\\n (address(converterNetwork) == address(0))\\n ) {\\n revert InvalidConverterNetwork();\\n }\\n\\n ConversionConfig storage configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n emit ConversionConfigUpdated(\\n tokenAddressIn,\\n tokenAddressOut,\\n configuration.incentive,\\n conversionConfig.incentive,\\n configuration.conversionAccess,\\n conversionConfig.conversionAccess\\n );\\n\\n if (conversionConfig.conversionAccess == ConversionAccessibility.NONE) {\\n delete conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n } else {\\n configuration.incentive = conversionConfig.incentive;\\n configuration.conversionAccess = conversionConfig.conversionAccess;\\n }\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) public view virtual returns (uint256 tokenBalance);\\n\\n /// @dev Operations to perform before sweeping tokens\\n /// @param token Address of the token\\n /// @param amount Amount transferred to address(to)\\n function preSweepToken(address token, uint256 amount) internal virtual {}\\n\\n /// @dev Converts exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return amountOutMantissa Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function _convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 amountOutMantissa) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, amountOutMantissa) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n if (amountOutMantissa < amountOutMinMantissa) {\\n revert AmountOutLowerThanMinRequired(amountOutMantissa, amountOutMinMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for exact amount of tokenAddressOut used for non deflationry tokens\\n /// it is called by convertForExactTokens function\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error DeflationaryTokenNotSupported is thrown if tokenAddressIn is deflationary token\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert DeflationaryTokenNotSupported();\\n }\\n\\n if (actualAmountIn > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n actualAmountOut = amountOutMantissa;\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for the amount of tokenAddressOut used for deflationary tokens\\n /// it is called by convertForExactTokensSupportingFeeOnTransferTokens function\\n /// @notice Advising users to input a smaller amountOutMantissa to avoid potential transaction revert\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n if (amountInMantissa > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, actualAmountOut) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n _doTransferOut(tokenAddressOut, to, actualAmountOut);\\n }\\n\\n /// @dev return actualAmountOut from reserves for tokenAddressOut\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred\\n /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n function _doTransferOut(\\n address tokenAddressOut,\\n address to,\\n uint256 amountConvertedMantissa\\n ) internal {\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountConvertedMantissa) {\\n revert InsufficientPoolLiquidity();\\n }\\n\\n _preTransferHook(tokenAddressOut, amountConvertedMantissa);\\n\\n IERC20Upgradeable tokenOut = IERC20Upgradeable(tokenAddressOut);\\n tokenOut.safeTransfer(to, amountConvertedMantissa);\\n }\\n\\n /// @notice Transfer tokenAddressIn from user to destination\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @return actualAmountIn Actual amount transferred to destination\\n function _doTransferIn(address tokenAddressIn, uint256 amountInMantissa) internal returns (uint256 actualAmountIn) {\\n IERC20Upgradeable tokenIn = IERC20Upgradeable(tokenAddressIn);\\n uint256 balanceBeforeDestination = tokenIn.balanceOf(destinationAddress);\\n tokenIn.safeTransferFrom(msg.sender, destinationAddress, amountInMantissa);\\n uint256 balanceAfterDestination = tokenIn.balanceOf(destinationAddress);\\n actualAmountIn = balanceAfterDestination - balanceBeforeDestination;\\n }\\n\\n /// @dev Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:event Emits PriceOracleUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero\\n function _setPriceOracle(ResilientOracle priceOracle_) internal {\\n ensureNonzeroAddress(address(priceOracle_));\\n emit PriceOracleUpdated(priceOracle, priceOracle_);\\n priceOracle = priceOracle_;\\n }\\n\\n /// @dev Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:event Emits DestinationAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when destination address is zero\\n function _setDestination(address destinationAddress_) internal {\\n ensureNonzeroAddress(destinationAddress_);\\n emit DestinationAddressUpdated(destinationAddress, destinationAddress_);\\n destinationAddress = destinationAddress_;\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:event Emits ConverterNetworkAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n function _setConverterNetwork(IConverterNetwork converterNetwork_) internal {\\n ensureNonzeroAddress(address(converterNetwork_));\\n emit ConverterNetworkAddressUpdated(address(converterNetwork), address(converterNetwork_));\\n converterNetwork = converterNetwork_;\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:event MinAmountToConvertUpdated is emitted in success\\n /// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\n function _setMinAmountToConvert(uint256 minAmountToConvert_) internal {\\n ensureNonzeroValue(minAmountToConvert_);\\n emit MinAmountToConvertUpdated(minAmountToConvert, minAmountToConvert_);\\n minAmountToConvert = minAmountToConvert_;\\n }\\n\\n /// @dev Hook to perform after converting tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param amountIn Amount of tokenIn converted\\n /// @param amountOut Amount of tokenOut converted\\n function _postConversionHook(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n ) internal virtual {}\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n __AccessControlled_init(accessControlManager_);\\n __ReentrancyGuard_init();\\n __AbstractTokenConverter_init_unchained(priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init_unchained(\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n _setPriceOracle(priceOracle_);\\n _setDestination(destinationAddress_);\\n _setMinAmountToConvert(minAmountToConvert_);\\n conversionPaused = false;\\n }\\n\\n /// @dev _updateAssetsState hook to update the states of reserves transferred for the specific comptroller\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n /// @return Amount of asset, for _privateConversion\\n function _updateAssetsState(address comptroller, address asset) internal virtual returns (uint256) {}\\n\\n /// @dev This method is used to convert asset into base asset by converting them with other converters which supports the pair and transfer the funds to\\n /// destination contract as destination's base asset\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset\\n /// @param amountToConvert Amount of the tokenAddressOut transferred to converter\\n function _privateConversion(\\n address comptroller,\\n address tokenAddressOut,\\n uint256 amountToConvert\\n ) internal {\\n address tokenAddressIn = _getDestinationBaseAsset();\\n address _destinationAddress = destinationAddress;\\n uint256 convertedTokenInBalance;\\n if (address(converterNetwork) != address(0)) {\\n (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork\\n .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn);\\n uint256 convertersLength = converterAddresses.length;\\n for (uint256 i; i < convertersLength; ) {\\n if (converterBalances[i] == 0) break;\\n (, uint256 amountIn) = IAbstractTokenConverter(converterAddresses[i]).getUpdatedAmountIn(\\n converterBalances[i],\\n tokenAddressOut,\\n tokenAddressIn\\n );\\n if (amountIn > amountToConvert) {\\n amountIn = amountToConvert;\\n }\\n\\n if (!_validateMinAmountToConvert(amountIn, tokenAddressOut)) {\\n break;\\n }\\n\\n uint256 balanceBefore = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n\\n IERC20Upgradeable(tokenAddressOut).forceApprove(converterAddresses[i], amountIn);\\n IAbstractTokenConverter(converterAddresses[i]).convertExactTokens(\\n amountIn,\\n 0,\\n tokenAddressOut,\\n tokenAddressIn,\\n _destinationAddress\\n );\\n\\n uint256 balanceAfter = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n amountToConvert -= amountIn;\\n convertedTokenInBalance += (balanceAfter - balanceBefore);\\n\\n if (amountToConvert == 0) break;\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n _postPrivateConversionHook(\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance,\\n tokenAddressOut,\\n amountToConvert\\n );\\n }\\n\\n /// @dev This hook is used to update states for the converter after the privateConversion\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressIn Address of the destination's base asset\\n /// @param convertedTokenInBalance Amount of the base asset received after the conversion\\n /// @param tokenAddressOut Address of the asset transferred to other converter in exchange of base asset\\n /// @param convertedTokenOutBalance Amount of tokenAddressOut transferred from this converter\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address tokenAddressOut,\\n uint256 convertedTokenOutBalance\\n ) internal virtual {}\\n\\n /// @notice This hook is used to update the state for asset reserves before transferring tokenOut to user\\n /// @param tokenOutAddress Address of the asset to be transferred to the user\\n /// @param amountOut Amount of tokenAddressOut transferred from this converter\\n function _preTransferHook(address tokenOutAddress, uint256 amountOut) internal virtual {}\\n\\n /// @dev Checks if amount to convert is greater than minimum amount to convert or not\\n /// @param amountIn The amount to convert\\n /// @param tokenAddress Address of the token\\n /// @return isValid true if amount to convert is greater than minimum amount to convert\\n function _validateMinAmountToConvert(uint256 amountIn, address tokenAddress) internal returns (bool isValid) {\\n priceOracle.updateAssetPrice(tokenAddress);\\n uint256 amountInInUsd = (priceOracle.getPrice(tokenAddress) * amountIn) / EXP_SCALE;\\n\\n if (amountInInUsd >= minAmountToConvert) {\\n isValid = true;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountOutMantissa, uint256 tokenInToOutConversion) {\\n if (amountInMantissa == 0) {\\n revert InsufficientInputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n if (address(converterNetwork) != address(0) && (converterNetwork.isTokenConverter(msg.sender))) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n /// amount of tokenAddressOut after including incentive as amountOutMantissa will be greater than actual as it gets\\n /// multiplied by conversionWithIncentive which will be >= 1\\n amountOutMantissa = (amountInMantissa * tokenInToOutConversion) / (EXP_SCALE);\\n }\\n\\n /// @dev To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @dev For user conversions, the function returns an amountInMantissa that is rounded up, ensuring that the equivalent amountInMantissa\\n /// is obtained from users for corresponding amountOutMantissa, preventing any losses to the protocol. However, no rounding up is required for private conversions\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountInMantissa, uint256 tokenInToOutConversion) {\\n if (amountOutMantissa == 0) {\\n revert InsufficientOutputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n\\n bool isPrivateConversion = address(converterNetwork) != address(0) &&\\n converterNetwork.isTokenConverter(msg.sender);\\n if (isPrivateConversion) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n /// amount of tokenAddressIn after considering incentive(i.e. amountInMantissa will be less than actual amountInMantissa if incentive > 0)\\n if (isPrivateConversion) {\\n amountInMantissa =\\n (amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE) /\\n (tokenInUnderlyingPrice * conversionWithIncentive);\\n } else {\\n amountInMantissa = _divRoundingUp(\\n amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE,\\n tokenInUnderlyingPrice * conversionWithIncentive\\n );\\n }\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n }\\n\\n /// @dev Check if msg.sender is allowed to convert as per onlyForPrivateConversions flag\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function _checkPrivateConversion(address tokenAddressIn, address tokenAddressOut) internal view {\\n bool isConverter = (address(converterNetwork) != address(0)) && converterNetwork.isTokenConverter(msg.sender);\\n if (\\n (!(isConverter) &&\\n (conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS))\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n }\\n\\n /// @dev To check, is conversion paused\\n /// @custom:error ConversionTokensPaused is thrown when token conversion is paused\\n function _checkConversionPaused() internal view {\\n if (conversionPaused) {\\n revert ConversionTokensPaused();\\n }\\n }\\n\\n /// @dev Get base asset address of the destination contract\\n /// @return Address of the base asset\\n function _getDestinationBaseAsset() internal view virtual returns (address) {}\\n\\n /// @dev Performs division where the result is rounded up\\n /// @param numerator The numerator of the division operation\\n /// @param denominator The denominator of the division operation. Must be non-zero\\n /// @return The result of the division, rounded up\\n function _divRoundingUp(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\\n return (numerator + denominator - 1) / denominator;\\n }\\n}\\n\",\"keccak256\":\"0xf87680dcb5a46a16663923c575661eda78ef57d29b7d78a85ddac00062426e18\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/IAbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @notice Interface for AbstractTokenConverter\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ninterface IAbstractTokenConverter {\\n /// @notice This enum define the all possible ways of conversion can happen\\n enum ConversionAccessibility {\\n NONE, // Conversion is disable for the pair\\n ALL, // Conversion is enable for private conversion and users\\n ONLY_FOR_CONVERTERS, // Conversion is enable only for private conversion\\n ONLY_FOR_USERS // Conversion is enable only for users\\n }\\n\\n /// @notice This struct represents the configuration for a token conversion.\\n struct ConversionConfig {\\n /// incentive on conversion of tokens in mantissa i.e 10% incentive would be 0.1 * 1e18\\n uint256 incentive;\\n /// enable or disable conversion for users or converters or both or none\\n ConversionAccessibility conversionAccess;\\n }\\n\\n /// @notice Pause conversion of tokens\\n function pauseConversion() external;\\n\\n /// @notice Resume conversion of tokens.\\n function resumeConversion() external;\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n function setPriceOracle(ResilientOracle priceOracle_) external;\\n\\n /// @notice Set the configuration for new or existing convert pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) external;\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Get the configuration for the pair of the tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return incentives Percentage of incentives to be distributed for the pair of tokens\\n /// @return conversionAccess Accessibility for the pair of tokens\\n function conversionConfigurations(address tokenAddressIn, address tokenAddressOut)\\n external\\n returns (uint256 incentives, ConversionAccessibility conversionAccess);\\n\\n /// @notice Get the address of the converterNetwork\\n function converterNetwork() external returns (IConverterNetwork converterNetwork);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) external view returns (uint256 tokenBalance);\\n}\\n\",\"keccak256\":\"0x7852d4f8a6dd1c80d14342f8ff2e26f723eb00c888e9a9e50a5fe8f95c59200c\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/SingleTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\n\\nimport { AbstractTokenConverter } from \\\"./AbstractTokenConverter.sol\\\";\\n\\n/// @title SingleTokenConverter\\n/// @author Venus\\n/// @notice SingleTokenConverter used for token conversions and sends received tokens\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ncontract SingleTokenConverter is AbstractTokenConverter {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Address of the base asset token\\n address public baseAsset;\\n\\n /// @notice Emitted when base asset is updated\\n event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset);\\n\\n /// @notice Emmitted after the funds transferred to the destination address\\n event AssetTransferredToDestination(\\n address indexed receiver,\\n address indexed comptroller,\\n address indexed asset,\\n uint256 amount\\n );\\n\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor() {\\n // Note that the contract is upgradeable. Use initialize() or reinitializers\\n // to set the state variables.\\n _disableInitializers();\\n }\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param baseAsset_ Address of the base asset\\n /// @param minAmountToConvert_ Minimum amount to convert\\n function initialize(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n address baseAsset_,\\n uint256 minAmountToConvert_\\n ) public initializer {\\n _setBaseAsset(baseAsset_);\\n\\n // Initialize AbstractTokenConverter\\n __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @notice Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:access Only Governance\\n function setBaseAsset(address baseAsset_) external onlyOwner {\\n _setBaseAsset(baseAsset_);\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param tokenAddress Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n tokenBalance = token.balanceOf(address(this));\\n }\\n\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address.\\n /// @return balanceLeft Amount of asset, for _privateConversion\\n // solhint-disable-next-line\\n function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) {\\n IERC20Upgradeable token = IERC20Upgradeable(asset);\\n uint256 balance = token.balanceOf(address(this));\\n balanceLeft = balance;\\n\\n if (asset == baseAsset) {\\n balanceLeft = 0;\\n token.safeTransfer(destinationAddress, balance);\\n emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance);\\n }\\n }\\n\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address,\\n uint256\\n ) internal override {\\n if (convertedTokenInBalance > 0) {\\n emit AssetTransferredToDestination(\\n destinationAddress,\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance\\n );\\n }\\n }\\n\\n /// @dev Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n /// @custom:event BaseAssetUpdated is emitted on success\\n function _setBaseAsset(address baseAsset_) internal {\\n ensureNonzeroAddress(baseAsset_);\\n emit BaseAssetUpdated(baseAsset, baseAsset_);\\n baseAsset = baseAsset_;\\n }\\n\\n /// @dev Get base asset address\\n /// @return destinationBaseAsset Address of the base asset(baseAsset)\\n function _getDestinationBaseAsset() internal view override returns (address destinationBaseAsset) {\\n destinationBaseAsset = baseAsset;\\n }\\n}\\n\",\"keccak256\":\"0x907f72b2fe32429d4a0fc95e4daee85e313be2593a0ae5734559f019f66a2b37\",\"license\":\"BSD-3-Clause\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061025c5760003560e01c806379ba509711610145578063ca325469116100bd578063f04c31871161008c578063f2fde38b11610071578063f2fde38b14610533578063f7013ef614610546578063fe3da9841461055957600080fd5b8063f04c31871461050d578063f0dc7e9d1461052057600080fd5b8063ca325469146104c6578063cdf456e1146104d9578063e2ff7ea2146104ed578063e30c3978146104fc57600080fd5b8063b491ddf711610114578063b6828c57116100f9578063b6828c5714610498578063bc368b04146104ab578063c0654646146104b357600080fd5b8063b491ddf714610444578063b4a0bdf31461048757600080fd5b806379ba5097146104055780638da5cb5b1461040d57806390fa7b541461041e578063aac59a751461043157600080fd5b8063530e784f116101d85780636daa463b116101a757806370a082311161018c57806370a08231146103c9578063715018a6146103ea578063746460a9146103f257600080fd5b80636daa463b146103a35780636f1a30a8146103b657600080fd5b8063530e784f1461036257806358b904df146103755780635e1e63251461037d57806364aff9ec1461039057600080fd5b80630e32cb861161022f5780633606b26c116102145780633606b26c14610329578063439727a51461033c57806352e21a181461034f57600080fd5b80630e32cb86146103035780632630c12f1461031657600080fd5b806301e201781461026157806307aa239e146102915780630a0a05e6146102c65780630a9a2b72146102db575b600080fd5b60ff54610274906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b60fe546102b69074010000000000000000000000000000000000000000900460ff1681565b6040519015158152602001610288565b6102d96102d43660046139b6565b610562565b005b6102ee6102e93660046139d3565b610576565b60408051928352602083019190915201610288565b6102d96103113660046139b6565b610624565b60fc54610274906001600160a01b031681565b6102d96103373660046139b6565b610635565b6102ee61034a366004613a15565b610646565b6102d961035d3660046139b6565b610784565b6102d96103703660046139b6565b610795565b6102d96107a6565b6102ee61038b3660046139d3565b61088c565b6102d961039e366004613a74565b61095a565b6102ee6103b13660046139d3565b6109f7565b6102ee6103c43660046139d3565b610b00565b6103dc6103d73660046139b6565b610bff565b604051908152602001610288565b6102d9610c8c565b6102d9610400366004613ab5565b610ca0565b6102d9610ce7565b6033546001600160a01b0316610274565b6102ee61042c366004613a15565b610d77565b6102d961043f366004613ace565b610e61565b610479610452366004613ace565b60fd6020908152600092835260408084209091529082529020805460019091015460ff1682565b604051610288929190613b71565b6097546001600160a01b0316610274565b6102ee6104a6366004613a15565b610e97565b6102d9610f81565b6102d96104c1366004613bd1565b611033565b60fe54610274906001600160a01b031681565b61012d54610274906001600160a01b031681565b6103dc6706f05b59d3b2000081565b6065546001600160a01b0316610274565b6102ee61051b366004613a15565b6110d1565b6102d961052e366004613c85565b6111f4565b6102d96105413660046139b6565b611593565b6102d9610554366004613cf6565b61161c565b6103dc60fb5481565b61056a6117a6565b61057381611800565b50565b60008060026001600160a01b03808616600090815260fd602090815260408083209388168352929052206001015460ff1660038111156105b8576105b8613b07565b036105ef576040517f03410cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006105fa84610bff565b905085811015610608578095505b85925061061686868661187d565b508092505050935093915050565b61062c6117a6565b61057381611be3565b61063d6117a6565b61057381611cd8565b600080828585610654611d57565b61065d83611dac565b816001600160a01b0316836001600160a01b0316148061068e5750806001600160a01b0316836001600160a01b0316145b156106c5576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6106cd611dec565b6106da8a8a8a8a8a611e45565b9095509350898514610718576040517fc214279600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604080516001600160a01b038a81168252602082018890529181018690528189169188169033907f795a235be939acb902ac69562805f86e1341a9b019c351b996e2aa2dfc34c67c906060015b60405180910390a4610777600160c955565b5050509550959350505050565b61078c6117a6565b61057381611ecc565b61079d6117a6565b61057381611f49565b6107e46040518060400160405280601281526020017f726573756d65436f6e76657273696f6e28290000000000000000000000000000815250611fc6565b60fe5474010000000000000000000000000000000000000000900460ff16610837576040517e6d8dbb00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fe80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff16905560405133907f89b79206f08dadd78502cff5075d2b094fa0abea0b063cfafe4475e2a380c51f90600090a2565b60008060026001600160a01b03808616600090815260fd602090815260408083209388168352929052206001015460ff1660038111156108ce576108ce613b07565b03610905576040517f03410cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8491506000610915868686612092565b9092509050600061092585610bff565b9050828110156109505761094a610944670de0b6b3a764000083613d89565b8361239f565b93508092505b5050935093915050565b6109626117a6565b61096a611dec565b61097383611dac565b61097c82611dac565b610985816123cb565b8261099a6001600160a01b0382168484612405565b826001600160a01b0316846001600160a01b03167f6d25be279134f4ecaa4770aff0c3d916d9e7c5ef37b65ed95dbdba411f5d54d5846040516109df91815260200190565b60405180910390a3506109f2600160c955565b505050565b60fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038481166004830152600092839291169063b62cad6990602401600060405180830381600087803b158015610a5b57600080fd5b505af1158015610a6f573d6000803e3d6000fd5b505060fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038781166004830152909116925063b62cad699150602401600060405180830381600087803b158015610ad357600080fd5b505af1158015610ae7573d6000803e3d6000fd5b50505050610af6858585612092565b5094959350505050565b60fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038481166004830152600092839291169063b62cad6990602401600060405180830381600087803b158015610b6457600080fd5b505af1158015610b78573d6000803e3d6000fd5b505060fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038781166004830152909116925063b62cad699150602401600060405180830381600087803b158015610bdc57600080fd5b505af1158015610bf0573d6000803e3d6000fd5b50505050610af685858561187d565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015260009082906001600160a01b038216906370a0823190602401602060405180830381865afa158015610c61573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c859190613da0565b9392505050565b610c946117a6565b610c9e60006124cc565b565b610cde6040518060400160405280601e81526020017f7365744d696e416d6f756e74546f436f6e766572742875696e74323536290000815250611fc6565b610573816124fd565b60655433906001600160a01b03168114610d6e5760405162461bcd60e51b815260206004820152602960248201527f4f776e61626c6532537465703a2063616c6c6572206973206e6f74207468652060448201527f6e6577206f776e6572000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b610573816124cc565b600080828585610d85611d57565b610d8e83611dac565b816001600160a01b0316836001600160a01b03161480610dbf5750806001600160a01b0316836001600160a01b0316145b15610df6576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610dfe611dec565b610e0b8a8a8a8a8a611e45565b9095509350604080516001600160a01b038a81168252602082018890529181018690528189169188169033907f93b7ba2a2b0e36320375853d7466af5685c07567804b871b4fdfd31e3bb7715490606001610765565b610e69611dec565b6000610e758383612547565b90508015610e8857610e8883838361265c565b50610e93600160c955565b5050565b600080828585610ea5611d57565b610eae83611dac565b816001600160a01b0316836001600160a01b03161480610edf5750806001600160a01b0316836001600160a01b0316145b15610f16576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610f1e611dec565b610f2b8a8a8a8a8a612ab9565b9095509350604080516001600160a01b038a81168252602082018890529181018690528189169188169033907f9b7dc1d7d2974d015b4fc39889a09f3a3923add808f5863158f3162d997d4e8290606001610765565b610fbf6040518060400160405280601181526020017f7061757365436f6e76657273696f6e2829000000000000000000000000000000815250611fc6565b610fc7611d57565b60fe80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000017905560405133907f490bc639fd0d96f19c8adf77bc98d17fbefdee2e1e1864d21f041360d0ee065a90600090a2565b8281811461106d576040517f4d5590f300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60005b818110156110c8576110c08787878481811061108e5761108e613db9565b90506020020160208101906110a391906139b6565b8686858181106110b5576110b5613db9565b9050604002016111f4565b600101611070565b50505050505050565b6000808285856110df611d57565b6110e883611dac565b816001600160a01b0316836001600160a01b031614806111195750806001600160a01b0316836001600160a01b0316145b15611150576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b611158611dec565b6111658a8a8a8a8a612b4b565b90955093508884146111a3576040517fa8dc653c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604080516001600160a01b038a81168252602082018890529181018690528189169188169033907fcb4ea7de8d069b0f443b792cba6c6df5096508951bbc75c04ac42c9251efe07690606001610765565b61121560405180606001604052806035815260200161419a60359139611fc6565b61121e83611dac565b61122782611dac565b6706f05b59d3b200008135111561127b576040517f9770caee000000000000000000000000000000000000000000000000000000008152813560048201526706f05b59d3b200006024820152604401610d65565b816001600160a01b0316836001600160a01b031614806112aa575061012d546001600160a01b03848116911614155b806112f2575060006001600160a01b03808416600090815260fd602090815260408083209388168352929052206001015460ff1660038111156112ef576112ef613b07565b14155b15611329576040517feebb5ac600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600261133b6040830160208401613de8565b600381111561134c5761134c613b07565b1480156113595750803515155b15611390576040517fd0d4aabe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60026113a26040830160208401613de8565b60038111156113b3576113b3613b07565b14806113df575060016113cc6040830160208401613de8565b60038111156113dd576113dd613b07565b145b80156113f4575060ff546001600160a01b0316155b1561142b576040517fe7c2c99400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b03808416600081815260fd602090815260408083209487168084529482529182902080546001820154919594937f39fbfdd5da133303ed31b1b65e30a0ddf7a9236573368c66c859dceccc1dd12a93919288359260ff9091169161149b91908a01908a01613de8565b6040516114ab9493929190613e09565b60405180910390a360006114c56040840160208501613de8565b60038111156114d6576114d6613b07565b03611533576001600160a01b03808516600090815260fd60209081526040808320938716835292905290812090815560010180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016905561158d565b813581556115476040830160208401613de8565b6001808301805490917fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff009091169083600381111561158757611587613b07565b02179055505b50505050565b61159b6117a6565b606580546001600160a01b0383167fffffffffffffffffffffffff000000000000000000000000000000000000000090911681179091556115e46033546001600160a01b031690565b6001600160a01b03167f38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e2270060405160405180910390a350565b600054610100900460ff161580801561163c5750600054600160ff909116105b806116565750303b158015611656575060005460ff166001145b6116c85760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a65640000000000000000000000000000000000006064820152608401610d65565b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055801561172657600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b61172f83611cd8565b61173b86868685612c08565b801561179e57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b505050505050565b6033546001600160a01b03163314610c9e5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610d65565b61180981611dac565b60fe546040516001600160a01b038084169216907f9be3097b5c8b276786be52a244ee90d66efd34805d9eb16f168fb2b4aaae9a2b90600090a360fe80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b600080846000036118ba576040517f42301c2300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b03808516600090815260fd6020908152604080832093871683529281528282208351808501909452805484526001810154929392909183019060ff16600381111561190e5761190e613b07565b600381111561191f5761191f613b07565b905250905060008160200151600381111561193c5761193c613b07565b03611973576040517f618ce59700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483015260009216906341976e0990602401602060405180830381865afa1580156119d7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906119fb9190613da0565b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b038881166004830152929350600092909116906341976e0990602401602060405180830381865afa158015611a64573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611a889190613da0565b835160ff54919250906000906001600160a01b031615801590611b2b575060ff546040517f6c059fb10000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b0390911690636c059fb190602401602060405180830381865afa158015611b07573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b2b9190613e31565b90508015611b3857600091505b6000611b4c83670de0b6b3a7640000613e53565b90508115611b8c57611b5e8186613d89565b670de0b6b3a7640000611b71868e613d89565b611b7b9190613d89565b611b859190613e66565b9750611bbe565b611bbb670de0b6b3a7640000611ba2868e613d89565b611bac9190613d89565b611bb68388613d89565b61239f565b97505b83611bc98287613d89565b611bd39190613e66565b9650505050505050935093915050565b6001600160a01b038116611c5f5760405162461bcd60e51b815260206004820152602560248201527f696e76616c696420616365737320636f6e74726f6c206d616e6167657220616460448201527f64726573730000000000000000000000000000000000000000000000000000006064820152608401610d65565b609780546001600160a01b038381167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604080519190921680825260208201939093527f66fd58e82f7b31a2a5c30e0888f3093efe4e111b00cd2b0c31fe014601293aa0910160405180910390a15050565b611ce181611dac565b61012d546040516001600160a01b038084169216907f4fe44995ca2482562846e3c0413d9bd6147e9ce1881c66a8765e8542fef99f4290600090a361012d80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b60fe5474010000000000000000000000000000000000000000900460ff1615610c9e576040517f952bcf7f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b038116610573576040517f8579befe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600260c95403611e3e5760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610d65565b600260c955565b600080611e528585612ca1565b611e5c8588612dc1565b9150611e698286866109f7565b91505085811015611eb0576040517f228f8c110000000000000000000000000000000000000000000000000000000081526004810182905260248101879052604401610d65565b611ebb848483612f0c565b9550959350505050565b600160c955565b611ed581611dac565b60ff546040516001600160a01b038084169216907f50f1a16bf24734355b14ff800d132cc0a934808b8621d5623b41bc67f204881790600090a360ff80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b611f5281611dac565b60fc546040516001600160a01b038084169216907f56b5f80d8cac1479698aa7d01605fd6111e90b15fc4d2b377417f46034876cbd90600090a360fc80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b6097546040517f18c5e8ab0000000000000000000000000000000000000000000000000000000081526000916001600160a01b0316906318c5e8ab906120129033908690600401613f0f565b602060405180830381865afa15801561202f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906120539190613e31565b905080610e93573330836040517f4a3fa293000000000000000000000000000000000000000000000000000000008152600401610d6593929190613f31565b600080846000036120cf576040517f098fb56100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b03808516600090815260fd6020908152604080832093871683529281528282208351808501909452805484526001810154929392909183019060ff16600381111561212357612123613b07565b600381111561213457612134613b07565b905250905060008160200151600381111561215157612151613b07565b03612188576040517f618ce59700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483015260009216906341976e0990602401602060405180830381865afa1580156121ec573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906122109190613da0565b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b038881166004830152929350600092909116906341976e0990602401602060405180830381865afa158015612279573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061229d9190613da0565b835160ff54919250906001600160a01b03161580159061233d575060ff546040517f6c059fb10000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b0390911690636c059fb190602401602060405180830381865afa158015612319573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061233d9190613e31565b15612346575060005b600061235a82670de0b6b3a7640000613e53565b9050826123678286613d89565b6123719190613e66565b9550670de0b6b3a7640000612386878c613d89565b6123909190613e66565b96505050505050935093915050565b60008160016123ae8286613e53565b6123b89190613f5d565b6123c29190613e66565b90505b92915050565b80600003610573576040517f9cf8540c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040516001600160a01b0383166024820152604481018290526109f29084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064015b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090931692909217909152612f6f565b606580547fffffffffffffffffffffffff000000000000000000000000000000000000000016905561057381613057565b612506816123cb565b60fb5460408051918252602082018390527fada67d0d38fa20c8ae6a5c17cb9d60b0fe7f2d4e4f27ac9ee55e54ac88de9d8d910160405180910390a160fb55565b6040517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152600090829082906001600160a01b038316906370a0823190602401602060405180830381865afa1580156125ab573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906125cf9190613da0565b61012d549093508391506001600160a01b03908116908516036126545760fe546000935061260a906001600160a01b03848116911683612405565b60fe546040518281526001600160a01b0386811692888216929116907fadc20ad416881f76b4304665c35f5be8592297bcdfe4f0bb087b9d254222af559060200160405180910390a45b505092915050565b600061267161012d546001600160a01b031690565b60fe5460ff549192506001600160a01b03908116916000911615612aac5760ff546040517f4e9f8f390000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483015285811660248301526000928392911690634e9f8f39906044016000604051808303816000875af1158015612700573d6000803e3d6000fd5b505050506040513d6000823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01682016040526127469190810190614081565b8151919350915060005b81811015612aa75782818151811061276a5761276a613db9565b602002602001015160000315612aa757600084828151811061278e5761278e613db9565b60200260200101516001600160a01b0316636f1a30a88584815181106127b6576127b6613db9565b60200260200101518c8b6040518463ffffffff1660e01b81526004016127f8939291909283526001600160a01b03918216602084015216604082015260600190565b60408051808303816000875af1158015612816573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061283a9190614146565b915050888111156128485750875b612852818b6130c1565b61285c5750612aa7565b6040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b038881166004830152600091908a16906370a0823190602401602060405180830381865afa1580156128bf573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906128e39190613da0565b905061291c8684815181106128fa576128fa613db9565b6020026020010151838d6001600160a01b03166131f99092919063ffffffff16565b85838151811061292e5761292e613db9565b60209081029190910101516040517f439727a500000000000000000000000000000000000000000000000000000000815260048101849052600060248201526001600160a01b038d811660448301528b811660648301528a811660848301529091169063439727a59060a40160408051808303816000875af11580156129b8573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129dc9190614146565b50506040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b038981166004830152600091908b16906370a0823190602401602060405180830381865afa158015612a41573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612a659190613da0565b9050612a71838c613f5d565b9a50612a7d8282613f5d565b612a879089613e53565b97508a600003612a9957505050612aa7565b836001019350505050612750565b505050505b61179e86848388886132cf565b600080612ac68585612ca1565b6000612ad3878787610b00565b91505087811115612b1a576040517f71b5f0c10000000000000000000000000000000000000000000000000000000081526004810182905260248101899052604401610d65565b612b248682612dc1565b9250612b318387876109f7565b9250612b409050858584612f0c565b509550959350505050565b600080612b588585612ca1565b6000612b65878787610b00565b915050612b728682612dc1565b9250808314612bad576040517f0c5c1c2000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b87831115612bf1576040517f71b5f0c10000000000000000000000000000000000000000000000000000000081526004810182905260248101899052604401610d65565b612bfc858589612f0c565b50909694955050505050565b600054610100900460ff16612c855760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b612c8e84613325565b612c966133b3565b61158d838383613438565b60ff546000906001600160a01b031615801590612d3e575060ff546040517f6c059fb10000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b0390911690636c059fb190602401602060405180830381865afa158015612d1a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612d3e9190613e31565b905080158015612d8a575060026001600160a01b03808516600090815260fd602090815260408083209387168352929052206001015460ff166003811115612d8857612d88613b07565b145b156109f2576040517f03410cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fe546040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b039182166004820152600091849183918316906370a0823190602401602060405180830381865afa158015612e2a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612e4e9190613da0565b60fe54909150612e6d906001600160a01b0384811691339116876134fd565b60fe546040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b0391821660048201526000918416906370a0823190602401602060405180830381865afa158015612ed2573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612ef69190613da0565b9050612f028282613f5d565b9695505050505050565b6000612f1784610bff565b905081811015612f53576040517f6bb2792900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b83612f686001600160a01b0382168585612405565b5050505050565b6000612fc4826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b031661354e9092919063ffffffff16565b9050805160001480612fe5575080806020019051810190612fe59190613e31565b6109f25760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610d65565b603380546001600160a01b038381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038381166004830152600092169063b62cad6990602401600060405180830381600087803b15801561312257600080fd5b505af1158015613136573d6000803e3d6000fd5b505060fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b03868116600483015260009450670de0b6b3a76400009350879216906341976e0990602401602060405180830381865afa1580156131aa573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906131ce9190613da0565b6131d89190613d89565b6131e29190613e66565b905060fb5481106131f257600191505b5092915050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f095ea7b3000000000000000000000000000000000000000000000000000000001790526132788482613565565b61158d576040516001600160a01b0384166024820152600060448201526132c59085907f095ea7b3000000000000000000000000000000000000000000000000000000009060640161244a565b61158d8482612f6f565b8215612f685760fe546040518481526001600160a01b0386811692888216929116907fadc20ad416881f76b4304665c35f5be8592297bcdfe4f0bb087b9d254222af559060200160405180910390a45050505050565b600054610100900460ff166133a25760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b6133aa61360c565b61057381613691565b600054610100900460ff166134305760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b610c9e61370e565b600054610100900460ff166134b55760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b6134be83611f49565b6134c782611800565b6134d0816124fd565b505060fe80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff16905550565b6040516001600160a01b038085166024830152831660448201526064810182905261158d9085907f23b872dd000000000000000000000000000000000000000000000000000000009060840161244a565b606061355d848460008561378b565b949350505050565b6000806000846001600160a01b031684604051613582919061416a565b6000604051808303816000865af19150503d80600081146135bf576040519150601f19603f3d011682016040523d82523d6000602084013e6135c4565b606091505b50915091508180156135ee5750805115806135ee5750808060200190518101906135ee9190613e31565b801561360357506001600160a01b0385163b15155b95945050505050565b600054610100900460ff166136895760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b610c9e61387d565b600054610100900460ff1661062c5760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b600054610100900460ff16611ec55760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b6060824710156138035760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610d65565b600080866001600160a01b0316858760405161381f919061416a565b60006040518083038185875af1925050503d806000811461385c576040519150601f19603f3d011682016040523d82523d6000602084013e613861565b606091505b509150915061387287838387613903565b979650505050505050565b600054610100900460ff166138fa5760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b610c9e336124cc565b6060831561397257825160000361396b576001600160a01b0385163b61396b5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610d65565b508161355d565b61355d83838151156139875781518083602001fd5b8060405162461bcd60e51b8152600401610d659190614186565b6001600160a01b038116811461057357600080fd5b6000602082840312156139c857600080fd5b8135610c85816139a1565b6000806000606084860312156139e857600080fd5b8335925060208401356139fa816139a1565b91506040840135613a0a816139a1565b809150509250925092565b600080600080600060a08688031215613a2d57600080fd5b85359450602086013593506040860135613a46816139a1565b92506060860135613a56816139a1565b91506080860135613a66816139a1565b809150509295509295909350565b600080600060608486031215613a8957600080fd5b8335613a94816139a1565b92506020840135613aa4816139a1565b929592945050506040919091013590565b600060208284031215613ac757600080fd5b5035919050565b60008060408385031215613ae157600080fd5b8235613aec816139a1565b91506020830135613afc816139a1565b809150509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b60048110613b6d577f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b9052565b82815260408101610c856020830184613b36565b60008083601f840112613b9757600080fd5b50813567ffffffffffffffff811115613baf57600080fd5b6020830191508360208260061b8501011115613bca57600080fd5b9250929050565b600080600080600060608688031215613be957600080fd5b8535613bf4816139a1565b9450602086013567ffffffffffffffff80821115613c1157600080fd5b818801915088601f830112613c2557600080fd5b813581811115613c3457600080fd5b8960208260051b8501011115613c4957600080fd5b602083019650809550506040880135915080821115613c6757600080fd5b50613c7488828901613b85565b969995985093965092949392505050565b60008060008385036080811215613c9b57600080fd5b8435613ca6816139a1565b93506020850135613cb6816139a1565b925060407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc082011215613ce857600080fd5b506040840190509250925092565b600080600080600060a08688031215613d0e57600080fd5b8535613d19816139a1565b94506020860135613d29816139a1565b93506040860135613d39816139a1565b92506060860135613d49816139a1565b949793965091946080013592915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b80820281158282048414176123c5576123c5613d5a565b600060208284031215613db257600080fd5b5051919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600060208284031215613dfa57600080fd5b813560048110610c8557600080fd5b8481526020810184905260808101613e246040830185613b36565b6136036060830184613b36565b600060208284031215613e4357600080fd5b81518015158114610c8557600080fd5b808201808211156123c5576123c5613d5a565b600082613e9c577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b60005b83811015613ebc578181015183820152602001613ea4565b50506000910152565b60008151808452613edd816020860160208601613ea1565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b6001600160a01b038316815260406020820152600061355d6040830184613ec5565b60006001600160a01b038086168352808516602084015250606060408301526136036060830184613ec5565b818103818111156123c5576123c5613d5a565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff81118282101715613fe657613fe6613f70565b604052919050565b600067ffffffffffffffff82111561400857614008613f70565b5060051b60200190565b600082601f83011261402357600080fd5b8151602061403861403383613fee565b613f9f565b8083825260208201915060208460051b87010193508684111561405a57600080fd5b602086015b84811015614076578051835291830191830161405f565b509695505050505050565b6000806040838503121561409457600080fd5b825167ffffffffffffffff808211156140ac57600080fd5b818501915085601f8301126140c057600080fd5b815160206140d061403383613fee565b82815260059290921b840181019181810190898411156140ef57600080fd5b948201945b83861015614116578551614107816139a1565b825294820194908201906140f4565b9188015191965090935050508082111561412f57600080fd5b5061413c85828601614012565b9150509250929050565b6000806040838503121561415957600080fd5b505080516020909101519092909150565b6000825161417c818460208701613ea1565b9190910192915050565b6020815260006123c26020830184613ec556fe736574436f6e76657273696f6e436f6e66696728616464726573732c616464726573732c436f6e76657273696f6e436f6e66696729a2646970667358221220344f76b4d0000b9523eecb9df4a64afba3e71c8b4fe0560c93ff5d115f78deb364736f6c63430008190033", + "numDeployments": 4, + "solcInputHash": "dceb6d0de70f90933a7f2cdf26a987ca", + "metadata": "{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountInHigherThanMax\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountInMismatched\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountOutLowerThanMinRequired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountOutMismatched\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionConfigNotEnabled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionEnabledOnlyForPrivateConversions\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensActive\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensPaused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DeflationaryTokenNotSupported\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DirectTransferBaseAssetNotAllowed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxIncentive\",\"type\":\"uint256\"}],\"name\":\"IncentiveTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InputLengthMisMatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientInputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientOutputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientPoolLiquidity\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidConverterNetwork\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidMinimumAmountToConvert\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidToAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenConfigAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NonZeroIncentiveForPrivateConversion\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"SameAssetDirectTransferNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SameBaseAssetNotAllowed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"calledContract\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"methodSignature\",\"type\":\"string\"}],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddressNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroValueNotAllowed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"AssetTransferredToDestination\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"AssetsDirectTransferUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldBaseAsset\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newBaseAsset\",\"type\":\"address\"}],\"name\":\"BaseAssetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"oldAccess\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"newAccess\",\"type\":\"uint8\"}],\"name\":\"ConversionConfigUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionResumed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldConverterNetwork\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"converterNetwork\",\"type\":\"address\"}],\"name\":\"ConverterNetworkAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldDestinationAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"}],\"name\":\"DestinationAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldMinAmountToConvert\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newMinAmountToConvert\",\"type\":\"uint256\"}],\"name\":\"MinAmountToConvertUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldAccessControlManager\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAccessControlManager\",\"type\":\"address\"}],\"name\":\"NewAccessControlManager\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"oldPriceOracle\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle\",\"type\":\"address\"}],\"name\":\"PriceOracleUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SweepToken\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MAX_INCENTIVE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"accessControlManager\",\"outputs\":[{\"internalType\":\"contract IAccessControlManagerV8\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"assetsDirectTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"baseAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"conversionConfigurations\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"conversionPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"converterNetwork\",\"outputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"destinationAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"},{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minAmountToConvert\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"priceOracle\",\"outputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"}],\"name\":\"setAccessControlManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"assets\",\"type\":\"address[]\"},{\"internalType\":\"bool[]\",\"name\":\"values\",\"type\":\"bool[]\"}],\"name\":\"setAssetsDirectTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"}],\"name\":\"setBaseAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig\",\"name\":\"conversionConfig\",\"type\":\"tuple\"}],\"name\":\"setConversionConfig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"tokenAddressesOut\",\"type\":\"address[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig[]\",\"name\":\"conversionConfigs\",\"type\":\"tuple[]\"}],\"name\":\"setConversionConfigs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"converterNetwork_\",\"type\":\"address\"}],\"name\":\"setConverterNetwork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"}],\"name\":\"setDestination\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"setMinAmountToConvert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"}],\"name\":\"setPriceOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sweepToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"updateAssetsState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Venus\",\"custom:security-contact\":\"https://github.com/VenusProtocol/protocol-reserve#discussion\",\"errors\":{\"SameAssetDirectTransferNotAllowed(address,bool)\":[{\"params\":{\"asset\":\"The asset address whose `assetDirectTransfer` value went to be set\",\"value\":\"The value to be set\"}}]},\"events\":{\"Initialized(uint8)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"}},\"kind\":\"dev\",\"methods\":{\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"balanceOf(address)\":{\"params\":{\"tokenAddress\":\"Address of the token\"},\"returns\":{\"tokenBalance\":\"Balance of the token the contract has\"}},\"constructor\":{\"custom:oz-upgrades-unsafe-allow\":\"constructor\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissaAmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissaAmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\",\"custom:event\":\"Emits ConvertedForExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\",\"custom:event\":\"Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"getAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"getUpdatedAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getUpdatedAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"initialize(address,address,address,address,uint256)\":{\"params\":{\"accessControlManager_\":\"Access control manager contract address\",\"baseAsset_\":\"Address of the base asset\",\"destinationAddress_\":\"Address at all incoming tokens will transferred to\",\"minAmountToConvert_\":\"Minimum amount to convert\",\"priceOracle_\":\"Resilient oracle address\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pauseConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensPaused thrown when conversion is already paused\",\"custom:event\":\"Emits ConversionPaused on success\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"resumeConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensActive thrown when conversion is already active\",\"custom:event\":\"Emits ConversionResumed on success\"},\"setAccessControlManager(address)\":{\"custom:access\":\"Only Governance\",\"custom:event\":\"Emits NewAccessControlManager event\",\"details\":\"Admin function to set address of AccessControlManager\",\"params\":{\"accessControlManager_\":\"The new address of the AccessControlManager\"}},\"setAssetsDirectTransfer(address[],bool[])\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"InputLengthMisMatch thrown when assets and values array lengths don't match\",\"custom:event\":\"AssetsDirectTransferUpdated emits on success\",\"params\":{\"assets\":\"Addresses of the assets need to be added or removed for direct transfer\",\"values\":\"Boolean value to indicate whether direct transfer is allowed for each asset.\"}},\"setBaseAsset(address)\":{\"custom:access\":\"Only Governance\",\"custom:error\":\"ZeroAddressNotAllowed is thrown when address is zeroSameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\",\"custom:event\":\"BaseAssetUpdated is emitted on success\",\"params\":{\"baseAsset_\":\"The new address of the base asset\"}},\"setConversionConfig(address,address,(uint256,uint8))\":{\"custom:access\":\"Controlled by AccessControlManager\",\"custom:error\":\"Unauthorized error is thrown when the call is not authorized by AccessControlManagerZeroAddressNotAllowed is thrown when pool registry address is zeroNonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\",\"custom:event\":\"Emits ConversionConfigUpdated event on success\",\"params\":{\"conversionConfig\":\"ConversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressOut\":\"Address of tokenOut\"}},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"custom:error\":\"InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\",\"params\":{\"conversionConfigs\":\"Array of conversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressesOut\":\"Array of addresses of tokenOut\"}},\"setConverterNetwork(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"converterNetwork_\":\"The converterNetwork address to be set\"}},\"setDestination(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"destinationAddress_\":\"The new destination address to be set\"}},\"setMinAmountToConvert(uint256)\":{\"custom:access\":\"Only Governance\",\"params\":{\"minAmountToConvert_\":\"Min amount to convert\"}},\"setPriceOracle(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"priceOracle_\":\"Address of the new price oracle to set\"}},\"sweepToken(address,address,uint256)\":{\"custom:access\":\"Only Governance\",\"custom:error\":\"ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\",\"custom:event\":\"Emits SweepToken event on success\",\"params\":{\"amount\":\"The amount to transfer\",\"to\":\"The address to which tokens will be transferred\",\"tokenAddress\":\"The address of the ERC-20 token to sweep\"}},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner.\"},\"updateAssetsState(address,address)\":{\"details\":\"This function is called by protocolShareReservecall _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\",\"params\":{\"asset\":\"Asset address\",\"comptroller\":\"Comptroller address (pool)\"}}},\"stateVariables\":{\"assetsDirectTransfer\":{\"details\":\"Asset -> bool(should transfer directly on true)\"}},\"title\":\"SingleTokenConverter\",\"version\":1},\"userdoc\":{\"errors\":{\"AmountInHigherThanMax(uint256,uint256)\":[{\"notice\":\"Thrown when amountIn is higher than amountInMax\"}],\"AmountInMismatched()\":[{\"notice\":\"Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\"}],\"AmountOutLowerThanMinRequired(uint256,uint256)\":[{\"notice\":\"Thrown when amountOut is lower than amountOutMin\"}],\"AmountOutMismatched()\":[{\"notice\":\"Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\"}],\"ConversionConfigNotEnabled()\":[{\"notice\":\"Thrown when conversion is disabled or config does not exist for given pair\"}],\"ConversionEnabledOnlyForPrivateConversions()\":[{\"notice\":\"Thrown when conversion is enabled only for private conversions\"}],\"ConversionTokensActive()\":[{\"notice\":\"Thrown when conversion is Active\"}],\"ConversionTokensPaused()\":[{\"notice\":\"Thrown when conversion is paused\"}],\"DeflationaryTokenNotSupported()\":[{\"notice\":\"Thrown when using convertForExactTokens deflationary tokens\"}],\"DirectTransferBaseAssetNotAllowed()\":[{\"notice\":\"Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection\"}],\"IncentiveTooHigh(uint256,uint256)\":[{\"notice\":\"Thrown when incentive is higher than the MAX_INCENTIVE\"}],\"InputLengthMisMatch()\":[{\"notice\":\"Thrown when there is a mismatch in the length of input arrays\"}],\"InsufficientInputAmount()\":[{\"notice\":\"Thrown when given input amount is zero\"}],\"InsufficientOutputAmount()\":[{\"notice\":\"Thrown when given output amount is zero\"}],\"InsufficientPoolLiquidity()\":[{\"notice\":\"Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\"}],\"InvalidConverterNetwork()\":[{\"notice\":\"When address of the ConverterNetwork is not set or Zero address\"}],\"InvalidMinimumAmountToConvert()\":[{\"notice\":\"Thrown when minimum amount to convert is zero\"}],\"InvalidToAddress()\":[{\"notice\":\"Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\"}],\"InvalidTokenConfigAddresses()\":[{\"notice\":\"Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\"}],\"NonZeroIncentiveForPrivateConversion()\":[{\"notice\":\"Thrown when trying to set non zero incentive for private conversion\"}],\"SameAssetDirectTransferNotAllowed(address,bool)\":[{\"notice\":\"Thrown when the `assetsDirectTransfer[asset]` is already `value`\"}],\"SameBaseAssetNotAllowed()\":[{\"notice\":\"Thrown when the base asset is the same as the new base asset\"}],\"Unauthorized(address,address,string)\":[{\"notice\":\"Thrown when the action is prohibited by AccessControlManager\"}],\"ZeroAddressNotAllowed()\":[{\"notice\":\"Thrown if the supplied address is a zero address where it is not allowed\"}],\"ZeroValueNotAllowed()\":[{\"notice\":\"Thrown if the supplied value is 0 where it is not allowed\"}]},\"events\":{\"AssetTransferredToDestination(address,address,address,uint256)\":{\"notice\":\"Emmitted after the funds transferred to the destination address\"},\"AssetsDirectTransferUpdated(address,address,bool)\":{\"notice\":\"Emitted after the assetsDirectTransfer mapping is updated\"},\"BaseAssetUpdated(address,address)\":{\"notice\":\"Emitted when base asset is updated\"},\"ConversionConfigUpdated(address,address,uint256,uint256,uint8,uint8)\":{\"notice\":\"Emitted when config is updated for tokens pair\"},\"ConversionPaused(address)\":{\"notice\":\"Emitted when conversion is paused\"},\"ConversionResumed(address)\":{\"notice\":\"Emitted when conversion is unpaused\"},\"ConvertedExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens\"},\"ConvertedExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\"},\"ConvertedForExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens\"},\"ConvertedForExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\"},\"ConverterNetworkAddressUpdated(address,address)\":{\"notice\":\"Emitted when converterNetwork address is updated\"},\"DestinationAddressUpdated(address,address)\":{\"notice\":\"Emitted when destination address is updated\"},\"MinAmountToConvertUpdated(uint256,uint256)\":{\"notice\":\"Emitted when minimum amount to convert is updated\"},\"NewAccessControlManager(address,address)\":{\"notice\":\"Emitted when access control manager contract address is changed\"},\"PriceOracleUpdated(address,address)\":{\"notice\":\"Emitted when price oracle address is updated\"},\"SweepToken(address,address,uint256)\":{\"notice\":\"Event emitted when tokens are swept\"}},\"kind\":\"user\",\"methods\":{\"MAX_INCENTIVE()\":{\"notice\":\"Maximum incentive could be\"},\"accessControlManager()\":{\"notice\":\"Returns the address of the access control manager contract\"},\"assetsDirectTransfer(address)\":{\"notice\":\"The mapping contains the assets which are sent to destination directly\"},\"balanceOf(address)\":{\"notice\":\"Get the balance for specific token\"},\"baseAsset()\":{\"notice\":\"Address of the base asset token\"},\"conversionConfigurations(address,address)\":{\"notice\":\"conversion configurations for the existing pairs\"},\"conversionPaused()\":{\"notice\":\"Boolean for if conversion is paused\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract, otherwise the amount is adjusted\"},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted. The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\"},\"converterNetwork()\":{\"notice\":\"Address of the converterNetwork contract\"},\"destinationAddress()\":{\"notice\":\"Address that all incoming tokens are transferred to\"},\"getAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut. This function does not account for potential token transfer fees(in case of deflationary tokens)\"},\"getAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn. This function does not account for potential token transfer fees(in case of deflationary tokens)The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\"},\"getUpdatedAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\"},\"getUpdatedAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\"},\"minAmountToConvert()\":{\"notice\":\"Min amount to convert for private conversions. Defined in USD, with 18 decimals\"},\"pauseConversion()\":{\"notice\":\"Pause conversion of tokens\"},\"priceOracle()\":{\"notice\":\"Venus price oracle contract\"},\"resumeConversion()\":{\"notice\":\"Resume conversion of tokens.\"},\"setAccessControlManager(address)\":{\"notice\":\"Sets the address of AccessControlManager\"},\"setAssetsDirectTransfer(address[],bool[])\":{\"notice\":\"Update the assetsDirectTransfer mapping\"},\"setBaseAsset(address)\":{\"notice\":\"Sets the base asset for the contract\"},\"setConversionConfig(address,address,(uint256,uint8))\":{\"notice\":\"Set the configuration for new or existing conversion pair\"},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"notice\":\"Batch sets the conversion configurations\"},\"setConverterNetwork(address)\":{\"notice\":\"Sets a converter network contract address\"},\"setDestination(address)\":{\"notice\":\"Sets a new destination address\"},\"setMinAmountToConvert(uint256)\":{\"notice\":\"Min amount to convert setter\"},\"setPriceOracle(address)\":{\"notice\":\"Sets a new price oracle\"},\"sweepToken(address,address,uint256)\":{\"notice\":\"To sweep ERC20 tokens and transfer them to user(to address)\"},\"updateAssetsState(address,address)\":{\"notice\":\"This method updated the states of this contract after getting funds from PSR after settling the amount(if any) through privateConversion between converters\"}},\"notice\":\"SingleTokenConverter used for token conversions and sends received tokens\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/TokenConverter/SingleTokenConverter.sol\":\"SingleTokenConverter\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./OwnableUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership} and {acceptOwnership}.\\n *\\n * This module is used through inheritance. It will make available all functions\\n * from parent (Ownable).\\n */\\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\\n function __Ownable2Step_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable2Step_init_unchained() internal onlyInitializing {\\n }\\n address private _pendingOwner;\\n\\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Returns the address of the pending owner.\\n */\\n function pendingOwner() public view virtual returns (address) {\\n return _pendingOwner;\\n }\\n\\n /**\\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual override onlyOwner {\\n _pendingOwner = newOwner;\\n emit OwnershipTransferStarted(owner(), newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual override {\\n delete _pendingOwner;\\n super._transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev The new owner accepts the ownership transfer.\\n */\\n function acceptOwnership() public virtual {\\n address sender = _msgSender();\\n require(pendingOwner() == sender, \\\"Ownable2Step: caller is not the new owner\\\");\\n _transferOwnership(sender);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x84efb8889801b0ac817324aff6acc691d07bbee816b671817132911d287a8c63\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n function __Ownable_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable_init_unchained() internal onlyInitializing {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby disabling any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x4075622496acc77fd6d4de4cc30a8577a744d5c75afad33fdeacf1704d6eda98\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts.\\n *\\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n * constructor.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n * are added through upgrades and that require initialization.\\n *\\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n * cannot be nested. If one is invoked in the context of another, execution will revert.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n *\\n * WARNING: setting the version to 255 will prevent any future reinitialization.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n *\\n * Emits an {Initialized} event the first time it is successfully executed.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized != type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n\\n /**\\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n */\\n function _getInitializedVersion() internal view returns (uint8) {\\n return _initialized;\\n }\\n\\n /**\\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n */\\n function _isInitializing() internal view returns (bool) {\\n return _initializing;\\n }\\n}\\n\",\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state.\\n */\\n function __Pausable_init() internal onlyInitializing {\\n __Pausable_init_unchained();\\n }\\n\\n function __Pausable_init_unchained() internal onlyInitializing {\\n _paused = false;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused() {\\n _requireNotPaused();\\n _;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier whenPaused() {\\n _requirePaused();\\n _;\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused() public view virtual returns (bool) {\\n return _paused;\\n }\\n\\n /**\\n * @dev Throws if the contract is paused.\\n */\\n function _requireNotPaused() internal view virtual {\\n require(!paused(), \\\"Pausable: paused\\\");\\n }\\n\\n /**\\n * @dev Throws if the contract is not paused.\\n */\\n function _requirePaused() internal view virtual {\\n require(paused(), \\\"Pausable: not paused\\\");\\n }\\n\\n /**\\n * @dev Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(_msgSender());\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n function __ReentrancyGuard_init() internal onlyInitializing {\\n __ReentrancyGuard_init_unchained();\\n }\\n\\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == _ENTERED;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xb82ef33f43b6b96109687d91b39c94573fdccaaa423fe28e8ba0977b31c023e0\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20PermitUpgradeable {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xd60f939a3ca0199014d079b4dd66aa757954334947d81eb5c1d35d7a83061ab3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\nimport \\\"../extensions/IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20Upgradeable {\\n using AddressUpgradeable for address;\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\\n * Revert on invalid signature.\\n */\\n function safePermit(\\n IERC20PermitUpgradeable token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return\\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));\\n }\\n}\\n\",\"keccak256\":\"0x23b997be73d3dd46885262704f0f8cfc7273fdadfe303d37969a9561373972b5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n *\\n * Furthermore, `isContract` will also return true if the target contract within\\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n * which only has an effect at the end of a transaction.\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal onlyInitializing {\\n }\\n\\n function __Context_init_unchained() internal onlyInitializing {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl {\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\"},\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\\\";\\n\\nimport \\\"./IAccessControlManagerV8.sol\\\";\\n\\n/**\\n * @title AccessControlledV8\\n * @author Venus\\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.8.13)\\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\\n */\\nabstract contract AccessControlledV8 is Initializable, Ownable2StepUpgradeable {\\n /// @notice Access control manager contract\\n IAccessControlManagerV8 private _accessControlManager;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n\\n /// @notice Emitted when access control manager contract address is changed\\n event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\\n\\n /// @notice Thrown when the action is prohibited by AccessControlManager\\n error Unauthorized(address sender, address calledContract, string methodSignature);\\n\\n function __AccessControlled_init(address accessControlManager_) internal onlyInitializing {\\n __Ownable2Step_init();\\n __AccessControlled_init_unchained(accessControlManager_);\\n }\\n\\n function __AccessControlled_init_unchained(address accessControlManager_) internal onlyInitializing {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Sets the address of AccessControlManager\\n * @dev Admin function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n * @custom:event Emits NewAccessControlManager event\\n * @custom:access Only Governance\\n */\\n function setAccessControlManager(address accessControlManager_) external onlyOwner {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Returns the address of the access control manager contract\\n */\\n function accessControlManager() external view returns (IAccessControlManagerV8) {\\n return _accessControlManager;\\n }\\n\\n /**\\n * @dev Internal function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n */\\n function _setAccessControlManager(address accessControlManager_) internal {\\n require(address(accessControlManager_) != address(0), \\\"invalid acess control manager address\\\");\\n address oldAccessControlManager = address(_accessControlManager);\\n _accessControlManager = IAccessControlManagerV8(accessControlManager_);\\n emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\\n }\\n\\n /**\\n * @notice Reverts if the call is not allowed by AccessControlManager\\n * @param signature Method signature\\n */\\n function _checkAccessAllowed(string memory signature) internal view {\\n bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\\n\\n if (!isAllowedToCall) {\\n revert Unauthorized(msg.sender, address(this), signature);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0dcf283925f4dddc23ca0ee71d2cb96a9dd6e4cf08061b69fde1697ea39dc514\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/access/IAccessControl.sol\\\";\\n\\n/**\\n * @title IAccessControlManagerV8\\n * @author Venus\\n * @notice Interface implemented by the `AccessControlManagerV8` contract.\\n */\\ninterface IAccessControlManagerV8 is IAccessControl {\\n function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\\n\\n function revokeCallPermission(\\n address contractAddress,\\n string calldata functionSig,\\n address accountToRevoke\\n ) external;\\n\\n function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\\n\\n function hasPermission(\\n address account,\\n address contractAddress,\\n string calldata functionSig\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xaa29b098440d0b3a131c5ecdf25ce548790c1b5ac7bf9b5c0264b6af6f7a1e0b\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/ResilientOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\n// SPDX-FileCopyrightText: 2022 Venus\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\nimport \\\"./interfaces/VBep20Interface.sol\\\";\\nimport \\\"./interfaces/OracleInterface.sol\\\";\\nimport \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\n\\n/**\\n * @title ResilientOracle\\n * @author Venus\\n * @notice The Resilient Oracle is the main contract that the protocol uses to fetch prices of assets.\\n *\\n * DeFi protocols are vulnerable to price oracle failures including oracle manipulation and incorrectly\\n * reported prices. If only one oracle is used, this creates a single point of failure and opens a vector\\n * for attacking the protocol.\\n *\\n * The Resilient Oracle uses multiple sources and fallback mechanisms to provide accurate prices and protect\\n * the protocol from oracle attacks. Currently it includes integrations with Chainlink, Pyth, Binance Oracle\\n * and TWAP (Time-Weighted Average Price) oracles. TWAP uses PancakeSwap as the on-chain price source.\\n *\\n * For every market (vToken) we configure the main, pivot and fallback oracles. The oracles are configured per\\n * vToken's underlying asset address. The main oracle oracle is the most trustworthy price source, the pivot\\n * oracle is used as a loose sanity checker and the fallback oracle is used as a backup price source.\\n *\\n * To validate prices returned from two oracles, we use an upper and lower bound ratio that is set for every\\n * market. The upper bound ratio represents the deviation between reported price (the price that\\u2019s being\\n * validated) and the anchor price (the price we are validating against) above which the reported price will\\n * be invalidated. The lower bound ratio presents the deviation between reported price and anchor price below\\n * which the reported price will be invalidated. So for oracle price to be considered valid the below statement\\n * should be true:\\n\\n```\\nanchorRatio = anchorPrice/reporterPrice\\nisValid = anchorRatio <= upperBoundAnchorRatio && anchorRatio >= lowerBoundAnchorRatio\\n```\\n\\n * In most cases, Chainlink is used as the main oracle, TWAP or Pyth oracles are used as the pivot oracle depending\\n * on which supports the given market and Binance oracle is used as the fallback oracle. For some markets we may\\n * use Pyth or TWAP as the main oracle if the token price is not supported by Chainlink or Binance oracles.\\n *\\n * For a fetched price to be valid it must be positive and not stagnant. If the price is invalid then we consider the\\n * oracle to be stagnant and treat it like it's disabled.\\n */\\ncontract ResilientOracle is PausableUpgradeable, AccessControlledV8, ResilientOracleInterface {\\n /**\\n * @dev Oracle roles:\\n * **main**: The most trustworthy price source\\n * **pivot**: Price oracle used as a loose sanity checker\\n * **fallback**: The backup source when main oracle price is invalidated\\n */\\n enum OracleRole {\\n MAIN,\\n PIVOT,\\n FALLBACK\\n }\\n\\n struct TokenConfig {\\n /// @notice asset address\\n address asset;\\n /// @notice `oracles` stores the oracles based on their role in the following order:\\n /// [main, pivot, fallback],\\n /// It can be indexed with the corresponding enum OracleRole value\\n address[3] oracles;\\n /// @notice `enableFlagsForOracles` stores the enabled state\\n /// for each oracle in the same order as `oracles`\\n bool[3] enableFlagsForOracles;\\n }\\n\\n uint256 public constant INVALID_PRICE = 0;\\n\\n /// @notice Native market address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable nativeMarket;\\n\\n /// @notice VAI address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable vai;\\n\\n /// @notice Set this as asset address for Native token on each chain.This is the underlying for vBNB (on bsc)\\n /// and can serve as any underlying asset of a market that supports native tokens\\n address public constant NATIVE_TOKEN_ADDR = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\\n\\n /// @notice Bound validator contract address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n BoundValidatorInterface public immutable boundValidator;\\n\\n mapping(address => TokenConfig) private tokenConfigs;\\n\\n event TokenConfigAdded(\\n address indexed asset,\\n address indexed mainOracle,\\n address indexed pivotOracle,\\n address fallbackOracle\\n );\\n\\n /// Event emitted when an oracle is set\\n event OracleSet(address indexed asset, address indexed oracle, uint256 indexed role);\\n\\n /// Event emitted when an oracle is enabled or disabled\\n event OracleEnabled(address indexed asset, uint256 indexed role, bool indexed enable);\\n\\n /**\\n * @notice Checks whether an address is null or not\\n */\\n modifier notNullAddress(address someone) {\\n if (someone == address(0)) revert(\\\"can't be zero address\\\");\\n _;\\n }\\n\\n /**\\n * @notice Checks whether token config exists by checking whether asset is null address\\n * @dev address can't be null, so it's suitable to be used to check the validity of the config\\n * @param asset asset address\\n */\\n modifier checkTokenConfigExistence(address asset) {\\n if (tokenConfigs[asset].asset == address(0)) revert(\\\"token config must exist\\\");\\n _;\\n }\\n\\n /// @notice Constructor for the implementation contract. Sets immutable variables.\\n /// @dev nativeMarketAddress can be address(0) if on the chain we do not support native market\\n /// (e.g vETH on ethereum would not be supported, only vWETH)\\n /// @param nativeMarketAddress The address of a native market (for bsc it would be vBNB address)\\n /// @param vaiAddress The address of the VAI token (if there is VAI on the deployed chain).\\n /// Set to address(0) of VAI is not existent.\\n /// @param _boundValidator Address of the bound validator contract\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor(\\n address nativeMarketAddress,\\n address vaiAddress,\\n BoundValidatorInterface _boundValidator\\n ) notNullAddress(address(_boundValidator)) {\\n nativeMarket = nativeMarketAddress;\\n vai = vaiAddress;\\n boundValidator = _boundValidator;\\n\\n _disableInitializers();\\n }\\n\\n /**\\n * @notice Initializes the contract admin and sets the BoundValidator contract address\\n * @param accessControlManager_ Address of the access control manager contract\\n */\\n function initialize(address accessControlManager_) external initializer {\\n __AccessControlled_init(accessControlManager_);\\n __Pausable_init();\\n }\\n\\n /**\\n * @notice Pauses oracle\\n * @custom:access Only Governance\\n */\\n function pause() external {\\n _checkAccessAllowed(\\\"pause()\\\");\\n _pause();\\n }\\n\\n /**\\n * @notice Unpauses oracle\\n * @custom:access Only Governance\\n */\\n function unpause() external {\\n _checkAccessAllowed(\\\"unpause()\\\");\\n _unpause();\\n }\\n\\n /**\\n * @notice Batch sets token configs\\n * @param tokenConfigs_ Token config array\\n * @custom:access Only Governance\\n * @custom:error Throws a length error if the length of the token configs array is 0\\n */\\n function setTokenConfigs(TokenConfig[] memory tokenConfigs_) external {\\n if (tokenConfigs_.length == 0) revert(\\\"length can't be 0\\\");\\n uint256 numTokenConfigs = tokenConfigs_.length;\\n for (uint256 i; i < numTokenConfigs; ) {\\n setTokenConfig(tokenConfigs_[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /**\\n * @notice Sets oracle for a given asset and role.\\n * @dev Supplied asset **must** exist and main oracle may not be null\\n * @param asset Asset address\\n * @param oracle Oracle address\\n * @param role Oracle role\\n * @custom:access Only Governance\\n * @custom:error Null address error if main-role oracle address is null\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n * @custom:event Emits OracleSet event with asset address, oracle address and role of the oracle for the asset\\n */\\n function setOracle(\\n address asset,\\n address oracle,\\n OracleRole role\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"setOracle(address,address,uint8)\\\");\\n if (oracle == address(0) && role == OracleRole.MAIN) revert(\\\"can't set zero address to main oracle\\\");\\n tokenConfigs[asset].oracles[uint256(role)] = oracle;\\n emit OracleSet(asset, oracle, uint256(role));\\n }\\n\\n /**\\n * @notice Enables/ disables oracle for the input asset. Token config for the input asset **must** exist\\n * @dev Configuration for the asset **must** already exist and the asset cannot be 0 address\\n * @param asset Asset address\\n * @param role Oracle role\\n * @param enable Enabled boolean of the oracle\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n */\\n function enableOracle(\\n address asset,\\n OracleRole role,\\n bool enable\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"enableOracle(address,uint8,bool)\\\");\\n tokenConfigs[asset].enableFlagsForOracles[uint256(role)] = enable;\\n emit OracleEnabled(asset, uint256(role), enable);\\n }\\n\\n /**\\n * @notice Updates the TWAP pivot oracle price.\\n * @dev This function should always be called before calling getUnderlyingPrice\\n * @param vToken vToken address\\n */\\n function updatePrice(address vToken) external override {\\n address asset = _getUnderlyingAsset(vToken);\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @notice Updates the pivot oracle price. Currently using TWAP\\n * @dev This function should always be called before calling getPrice\\n * @param asset asset address\\n */\\n function updateAssetPrice(address asset) external {\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @dev Gets token config by asset address\\n * @param asset asset address\\n * @return tokenConfig Config for the asset\\n */\\n function getTokenConfig(address asset) external view returns (TokenConfig memory) {\\n return tokenConfigs[asset];\\n }\\n\\n /**\\n * @notice Gets price of the underlying asset for a given vToken. Validation flow:\\n * - Check if the oracle is paused globally\\n * - Validate price from main oracle against pivot oracle\\n * - Validate price from fallback oracle against pivot oracle if the first validation failed\\n * - Validate price from main oracle against fallback oracle if the second validation failed\\n * In the case that the pivot oracle is not available but main price is available and validation is successful,\\n * main oracle price is returned.\\n * @param vToken vToken address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getUnderlyingPrice(address vToken) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n\\n address asset = _getUnderlyingAsset(vToken);\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Gets price of the asset\\n * @param asset asset address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getPrice(address asset) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Sets/resets single token configs.\\n * @dev main oracle **must not** be a null address\\n * @param tokenConfig Token config struct\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress is thrown if asset address is null\\n * @custom:error NotNullAddress is thrown if main-role oracle address for asset is null\\n * @custom:event Emits TokenConfigAdded event when the asset config is set successfully by the authorized account\\n */\\n function setTokenConfig(\\n TokenConfig memory tokenConfig\\n ) public notNullAddress(tokenConfig.asset) notNullAddress(tokenConfig.oracles[uint256(OracleRole.MAIN)]) {\\n _checkAccessAllowed(\\\"setTokenConfig(TokenConfig)\\\");\\n\\n tokenConfigs[tokenConfig.asset] = tokenConfig;\\n emit TokenConfigAdded(\\n tokenConfig.asset,\\n tokenConfig.oracles[uint256(OracleRole.MAIN)],\\n tokenConfig.oracles[uint256(OracleRole.PIVOT)],\\n tokenConfig.oracles[uint256(OracleRole.FALLBACK)]\\n );\\n }\\n\\n /**\\n * @notice Gets oracle and enabled status by asset address\\n * @param asset asset address\\n * @param role Oracle role\\n * @return oracle Oracle address based on role\\n * @return enabled Enabled flag of the oracle based on token config\\n */\\n function getOracle(address asset, OracleRole role) public view returns (address oracle, bool enabled) {\\n oracle = tokenConfigs[asset].oracles[uint256(role)];\\n enabled = tokenConfigs[asset].enableFlagsForOracles[uint256(role)];\\n }\\n\\n function _getPrice(address asset) internal view returns (uint256) {\\n uint256 pivotPrice = INVALID_PRICE;\\n\\n // Get pivot oracle price, Invalid price if not available or error\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracleEnabled && pivotOracle != address(0)) {\\n try OracleInterface(pivotOracle).getPrice(asset) returns (uint256 pricePivot) {\\n pivotPrice = pricePivot;\\n } catch {}\\n }\\n\\n // Compare main price and pivot price, return main price and if validation was successful\\n // note: In case pivot oracle is not available but main price is available and\\n // validation is successful, the main oracle price is returned.\\n (uint256 mainPrice, bool validatedPivotMain) = _getMainOraclePrice(\\n asset,\\n pivotPrice,\\n pivotOracleEnabled && pivotOracle != address(0)\\n );\\n if (mainPrice != INVALID_PRICE && validatedPivotMain) return mainPrice;\\n\\n // Compare fallback and pivot if main oracle comparision fails with pivot\\n // Return fallback price when fallback price is validated successfully with pivot oracle\\n (uint256 fallbackPrice, bool validatedPivotFallback) = _getFallbackOraclePrice(asset, pivotPrice);\\n if (fallbackPrice != INVALID_PRICE && validatedPivotFallback) return fallbackPrice;\\n\\n // Lastly compare main price and fallback price\\n if (\\n mainPrice != INVALID_PRICE &&\\n fallbackPrice != INVALID_PRICE &&\\n boundValidator.validatePriceWithAnchorPrice(asset, mainPrice, fallbackPrice)\\n ) {\\n return mainPrice;\\n }\\n\\n revert(\\\"invalid resilient oracle price\\\");\\n }\\n\\n /**\\n * @notice Gets a price for the provided asset\\n * @dev This function won't revert when price is 0, because the fallback oracle may still be\\n * able to fetch a correct price\\n * @param asset asset address\\n * @param pivotPrice Pivot oracle price\\n * @param pivotEnabled If pivot oracle is not empty and enabled\\n * @return price USD price in scaled decimals\\n * e.g. asset decimals is 8 then price is returned as 10**18 * 10**(18-8) = 10**28 decimals\\n * @return pivotValidated Boolean representing if the validation of main oracle price\\n * and pivot oracle price were successful\\n * @custom:error Invalid price error is thrown if main oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if main oracle is not enabled or main oracle\\n * address is null\\n */\\n function _getMainOraclePrice(\\n address asset,\\n uint256 pivotPrice,\\n bool pivotEnabled\\n ) internal view returns (uint256, bool) {\\n (address mainOracle, bool mainOracleEnabled) = getOracle(asset, OracleRole.MAIN);\\n if (mainOracleEnabled && mainOracle != address(0)) {\\n try OracleInterface(mainOracle).getPrice(asset) returns (uint256 mainOraclePrice) {\\n if (!pivotEnabled) {\\n return (mainOraclePrice, true);\\n }\\n if (pivotPrice == INVALID_PRICE) {\\n return (mainOraclePrice, false);\\n }\\n return (\\n mainOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, mainOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function won't revert when the price is 0 because getPrice checks if price is > 0\\n * @param asset asset address\\n * @return price USD price in 18 decimals\\n * @return pivotValidated Boolean representing if the validation of fallback oracle price\\n * and pivot oracle price were successfully\\n * @custom:error Invalid price error is thrown if fallback oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if fallback oracle is not enabled or fallback oracle\\n * address is null\\n */\\n function _getFallbackOraclePrice(address asset, uint256 pivotPrice) private view returns (uint256, bool) {\\n (address fallbackOracle, bool fallbackEnabled) = getOracle(asset, OracleRole.FALLBACK);\\n if (fallbackEnabled && fallbackOracle != address(0)) {\\n try OracleInterface(fallbackOracle).getPrice(asset) returns (uint256 fallbackOraclePrice) {\\n if (pivotPrice == INVALID_PRICE) {\\n return (fallbackOraclePrice, false);\\n }\\n return (\\n fallbackOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, fallbackOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function returns the underlying asset of a vToken\\n * @param vToken vToken address\\n * @return asset underlying asset address\\n */\\n function _getUnderlyingAsset(address vToken) private view notNullAddress(vToken) returns (address asset) {\\n if (vToken == nativeMarket) {\\n asset = NATIVE_TOKEN_ADDR;\\n } else if (vToken == vai) {\\n asset = vai;\\n } else {\\n asset = VBep20Interface(vToken).underlying();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xdaaa90daa8ca5bda477729aaa5d5ff3e5305635baec1799a368d564ae2a13c4c\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\ninterface OracleInterface {\\n function getPrice(address asset) external view returns (uint256);\\n}\\n\\ninterface ResilientOracleInterface is OracleInterface {\\n function updatePrice(address vToken) external;\\n\\n function updateAssetPrice(address asset) external;\\n\\n function getUnderlyingPrice(address vToken) external view returns (uint256);\\n}\\n\\ninterface TwapInterface is OracleInterface {\\n function updateTwap(address asset) external returns (uint256);\\n}\\n\\ninterface BoundValidatorInterface {\\n function validatePriceWithAnchorPrice(\\n address asset,\\n uint256 reporterPrice,\\n uint256 anchorPrice\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x2432799b0d824fc701beb4c30146e912b9aeecf77b5c1635dde6c5fbe6bfc3a7\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/VBep20Interface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\ninterface VBep20Interface is IERC20Metadata {\\n /**\\n * @notice Underlying asset for this VToken\\n */\\n function underlying() external view returns (address);\\n}\\n\",\"keccak256\":\"0x6e71c3df86501df5c0e4bace1333c0c91f9f9cced252a54fb99eeda219b789d5\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/constants.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\n/// @dev Base unit for computations, usually used in scaling (multiplications, divisions)\\nuint256 constant EXP_SCALE = 1e18;\\n\\n/// @dev A unit (literal one) in EXP_SCALE, usually used in additions/subtractions\\nuint256 constant MANTISSA_ONE = EXP_SCALE;\\n\\n/// @dev The approximate number of seconds per year\\nuint256 constant SECONDS_PER_YEAR = 31_536_000;\\n\",\"keccak256\":\"0x14de93ead464da249af31bea0e3bcfb62ec693bea3475fb4d90f055ac81dc5eb\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/validators.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\n/// @notice Thrown if the supplied address is a zero address where it is not allowed\\nerror ZeroAddressNotAllowed();\\n\\n/// @notice Thrown if the supplied value is 0 where it is not allowed\\nerror ZeroValueNotAllowed();\\n\\n/// @notice Checks if the provided address is nonzero, reverts otherwise\\n/// @param address_ Address to check\\n/// @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address\\nfunction ensureNonzeroAddress(address address_) pure {\\n if (address_ == address(0)) {\\n revert ZeroAddressNotAllowed();\\n }\\n}\\n\\n/// @notice Checks if the provided value is nonzero, reverts otherwise\\n/// @param value_ Value to check\\n/// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\nfunction ensureNonzeroValue(uint256 value_) pure {\\n if (value_ == 0) {\\n revert ZeroValueNotAllowed();\\n }\\n}\\n\",\"keccak256\":\"0xdb88e14d50dd21889ca3329d755673d022c47e8da005b6a545c7f69c2c4b7b86\",\"license\":\"BSD-3-Clause\"},\"contracts/Interfaces/IConverterNetwork.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { IAbstractTokenConverter } from \\\"../TokenConverter/IAbstractTokenConverter.sol\\\";\\n\\n/**\\n * @title IConverterNetwork\\n * @author Venus\\n * @notice Interface implemented by `ConverterNetwork`.\\n */\\ninterface IConverterNetwork {\\n /// @notice Adds new converter to the array\\n /// @param _tokenConverter Address of the token converter\\n function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Removes converter from the array\\n /// @param _tokenConverter Address of the token converter\\n function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice This function returns the array containing all the converters addresses\\n /// @return Array containing all the converters addresses\\n function getAllConverters() external view returns (IAbstractTokenConverter[] memory);\\n\\n /// @notice This function checks for given address is converter or not\\n /// @param _tokenConverter Address of the token converter\\n /// @return boolean true if given address is converter otherwise false\\n function isTokenConverter(address _tokenConverter) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xd9a747f176d9b9de220331b87ed711cc2bd594a118b538a35f3c47060bff7a8b\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/AbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { ReentrancyGuardUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { AccessControlledV8 } from \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress, ensureNonzeroValue } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\nimport { MANTISSA_ONE, EXP_SCALE } from \\\"@venusprotocol/solidity-utilities/contracts/constants.sol\\\";\\n\\nimport { IAbstractTokenConverter } from \\\"./IAbstractTokenConverter.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @title AbstractTokenConverter\\n/// @author Venus\\n/// @notice Abstract contract will be extended by SingleTokenConverter and RiskFundConverter\\n/*\\n * This contract specifies four functions for converting tokens, each applicable under following circumstances:\\n *\\n * Case I: TokenIn -> deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions supporting fees can only be utilized to convert tokens which are:\\n * a. convertExactTokensSupportingFeeOnTransferTokens\\n * b. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case II: TokenIn -> deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions supporting fee can only be utilized to convert tokens which are:\\n * similar to Case I.\\n *\\n * Case III: TokenIn -> non-deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * a. convertExactTokens\\n * b. convertForExactTokens\\n * c. convertExactTokensSupportingFeeOnTransferTokens\\n * d. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case IV: TokenIn -> non-deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * similar to Case III.\\n *\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n * Example 1:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInAmount - 100\\n * tokenOutMinAmount - minimum amount desired by the user(let's say 70)\\n * Here user can use `convertExactTokens` or `convertExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertExactTokens` is used).\\n * Now first tokenInAddress tokens will be transferred from the user to the contract, on the basis of amount\\n * received(as tokenInAddress can be deflationary token) tokenAmountOut will be calculated and will be transferred\\n * to the user and if amount sent is less than tokenOutMinAmount, tx will revert. If amount sent is satisfied(let's say\\n * 80 or even 70) then at last the actual amount received and the amount that was supposed to be received by the contract will\\n * be compared, if they differ then the whole tx will revert as user was supposed to use `convertExactTokensSupportingFeeOnTransferTokens`\\n * function for tokenIn as deflationary token.\\n *\\n * Example 2:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInMaxAmount - maximum amount user is willing to provide(let's say 100)\\n * tokenOutAmount - 70\\n * Here user can use `convertForExactTokens` or `convertForExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertForExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertForExactTokens` is used),\\n * which on the basis of tokenOutAmount provided will calculate tokenInAmount based on the tokens prices and will transfer\\n * tokens from the user to the contract, now the actual amount received(as tokenInAddress can be deflationary token) will be\\n * compared with tokenInMaxAmount if it is greater, tx will revert. If In amount is satisfied(let's say 90 or even 100) then\\n * new tokenOutAmount will be calculated, and tokenOutAddress tokens will be transferred to the user, but at last the\\n * old tokenOutAmount and new tokenOutAmount will be compared and if they differ whole tx will revert, because user was\\n * supposed to use `convertForExactTokensSupportingFeeOnTransferTokens` function for tokenIn as deflationary token.\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n *\\n * This contract also supports private conversion between the converters:\\n * Private conversions:\\n * Private conversions is designed in order to convert the maximum amount of tokens received from PSR(to any converter) between\\n * existing converters to save incentive and lower the dependency of users for conversion. So Private Conversion will be executed\\n * by converters on it's own whenever funds are received from PSR. No incentive will be offered during private conversion.\\n *\\n * It will execute on updateAssetsState() function call in Converter Contracts. After this function call, converter will first\\n * check for the amount received. If base asset is received then it will be directly sent to the destination address and no private\\n * conversion will happen otherwise converter will interact with ConverterNetwork contract to find other valid converters who are providing the conversion for:\\n *\\n * tokenAddressIn: As asset received by that converter on updateAssetsState() function call.\\n * tokenAddressOut: As base asset of that converter.\\n *\\n * ConverterNetwork:\\n * This contract will contain all the converters, and will provide valid converters which can perform the execution according to tokenAddressIn\\n * and tokenAddressOut provided.\\n *\\n * findTokenConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for users).\\n *\\n * findTokenConvertersForConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for converters).\\n */\\n\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\nabstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenConverter, ReentrancyGuardUpgradeable {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Maximum incentive could be\\n uint256 public constant MAX_INCENTIVE = 0.5e18;\\n\\n /// @notice Min amount to convert for private conversions. Defined in USD, with 18 decimals\\n uint256 public minAmountToConvert;\\n\\n /// @notice Venus price oracle contract\\n ResilientOracle public priceOracle;\\n\\n /// @notice conversion configurations for the existing pairs\\n /// @dev tokenAddressIn => tokenAddressOut => ConversionConfig\\n mapping(address => mapping(address => ConversionConfig)) public conversionConfigurations;\\n\\n /// @notice Address that all incoming tokens are transferred to\\n address public destinationAddress;\\n\\n /// @notice Boolean for if conversion is paused\\n bool public conversionPaused;\\n\\n /// @notice Address of the converterNetwork contract\\n IConverterNetwork public converterNetwork;\\n\\n /// @dev This empty reserved space is put in place to allow future versions to add new\\n /// variables without shifting down storage in the inheritance chain.\\n /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n uint256[45] private __gap;\\n\\n /// @notice Emitted when config is updated for tokens pair\\n event ConversionConfigUpdated(\\n address indexed tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 oldIncentive,\\n uint256 newIncentive,\\n ConversionAccessibility oldAccess,\\n ConversionAccessibility newAccess\\n );\\n /// @notice Emitted when price oracle address is updated\\n event PriceOracleUpdated(ResilientOracle indexed oldPriceOracle, ResilientOracle indexed priceOracle);\\n\\n /// @notice Emitted when destination address is updated\\n event DestinationAddressUpdated(address indexed oldDestinationAddress, address indexed destinationAddress);\\n\\n /// @notice Emitted when converterNetwork address is updated\\n event ConverterNetworkAddressUpdated(address indexed oldConverterNetwork, address indexed converterNetwork);\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens\\n event ConvertedExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens\\n event ConvertedForExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\\n event ConvertedExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\\n event ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when conversion is paused\\n event ConversionPaused(address indexed sender);\\n\\n /// @notice Emitted when conversion is unpaused\\n event ConversionResumed(address indexed sender);\\n\\n /// @notice Event emitted when tokens are swept\\n event SweepToken(address indexed token, address indexed to, uint256 amount);\\n\\n /// @notice Emitted when minimum amount to convert is updated\\n event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);\\n\\n /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\\n error AmountOutMismatched();\\n\\n /// @notice Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\\n error AmountInMismatched();\\n\\n /// @notice Thrown when given input amount is zero\\n error InsufficientInputAmount();\\n\\n /// @notice Thrown when given output amount is zero\\n error InsufficientOutputAmount();\\n\\n /// @notice Thrown when conversion is disabled or config does not exist for given pair\\n error ConversionConfigNotEnabled();\\n\\n /// @notice Thrown when conversion is enabled only for private conversions\\n error ConversionEnabledOnlyForPrivateConversions();\\n\\n /// @notice Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n error InvalidToAddress();\\n\\n /// @notice Thrown when incentive is higher than the MAX_INCENTIVE\\n error IncentiveTooHigh(uint256 incentive, uint256 maxIncentive);\\n\\n /// @notice Thrown when amountOut is lower than amountOutMin\\n error AmountOutLowerThanMinRequired(uint256 amountOutMantissa, uint256 amountOutMinMantissa);\\n\\n /// @notice Thrown when amountIn is higher than amountInMax\\n error AmountInHigherThanMax(uint256 amountInMantissa, uint256 amountInMaxMantissa);\\n\\n /// @notice Thrown when conversion is paused\\n error ConversionTokensPaused();\\n\\n /// @notice Thrown when conversion is Active\\n error ConversionTokensActive();\\n\\n /// @notice Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\\n error InvalidTokenConfigAddresses();\\n\\n /// @notice Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\\n error InsufficientPoolLiquidity();\\n\\n /// @notice When address of the ConverterNetwork is not set or Zero address\\n error InvalidConverterNetwork();\\n\\n /// @notice Thrown when trying to set non zero incentive for private conversion\\n error NonZeroIncentiveForPrivateConversion();\\n\\n /// @notice Thrown when using convertForExactTokens deflationary tokens\\n error DeflationaryTokenNotSupported();\\n\\n /// @notice Thrown when minimum amount to convert is zero\\n error InvalidMinimumAmountToConvert();\\n\\n /// @notice Thrown when there is a mismatch in the length of input arrays\\n error InputLengthMisMatch();\\n\\n /**\\n * @notice Modifier to ensure valid conversion parameters for a token conversion\\n * and check if conversion is paused or not\\n * @param to The recipient address for the converted tokens\\n * @param tokenAddressIn The input token address for the conversion\\n * @param tokenAddressOut The output token address for the conversion\\n */\\n modifier validConversionParameters(\\n address to,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) {\\n _checkConversionPaused();\\n ensureNonzeroAddress(to);\\n if (to == tokenAddressIn || to == tokenAddressOut) {\\n revert InvalidToAddress();\\n }\\n _;\\n }\\n\\n /// @notice Pause conversion of tokens\\n /// @custom:event Emits ConversionPaused on success\\n /// @custom:error ConversionTokensPaused thrown when conversion is already paused\\n /// @custom:access Restricted by ACM\\n function pauseConversion() external {\\n _checkAccessAllowed(\\\"pauseConversion()\\\");\\n _checkConversionPaused();\\n conversionPaused = true;\\n emit ConversionPaused(msg.sender);\\n }\\n\\n /// @notice Resume conversion of tokens.\\n /// @custom:event Emits ConversionResumed on success\\n /// @custom:error ConversionTokensActive thrown when conversion is already active\\n /// @custom:access Restricted by ACM\\n function resumeConversion() external {\\n _checkAccessAllowed(\\\"resumeConversion()\\\");\\n if (!conversionPaused) {\\n revert ConversionTokensActive();\\n }\\n\\n conversionPaused = false;\\n emit ConversionResumed(msg.sender);\\n }\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:access Only Governance\\n function setPriceOracle(ResilientOracle priceOracle_) external onlyOwner {\\n _setPriceOracle(priceOracle_);\\n }\\n\\n /// @notice Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:access Only Governance\\n function setDestination(address destinationAddress_) external onlyOwner {\\n _setDestination(destinationAddress_);\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:access Only Governance\\n function setConverterNetwork(IConverterNetwork converterNetwork_) external onlyOwner {\\n _setConverterNetwork(converterNetwork_);\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:access Only Governance\\n function setMinAmountToConvert(uint256 minAmountToConvert_) external {\\n _checkAccessAllowed(\\\"setMinAmountToConvert(uint256)\\\");\\n _setMinAmountToConvert(minAmountToConvert_);\\n }\\n\\n /// @notice Batch sets the conversion configurations\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressesOut Array of addresses of tokenOut\\n /// @param conversionConfigs Array of conversionConfig config details to update\\n /// @custom:error InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\\n function setConversionConfigs(\\n address tokenAddressIn,\\n address[] calldata tokenAddressesOut,\\n ConversionConfig[] calldata conversionConfigs\\n ) external {\\n uint256 tokenOutArrayLength = tokenAddressesOut.length;\\n if (tokenOutArrayLength != conversionConfigs.length) revert InputLengthMisMatch();\\n\\n for (uint256 i; i < tokenOutArrayLength; ) {\\n setConversionConfig(tokenAddressIn, tokenAddressesOut[i], conversionConfigs[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n /// @custom:error AmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert AmountInMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract,\\n /// otherwise the amount is adjusted\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n /// @custom:error AmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountOut != amountOutMantissa) {\\n revert AmountOutMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of\\n /// tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted.\\n /// The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokensSupportingFeeOnTransferTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice To sweep ERC20 tokens and transfer them to user(to address)\\n /// @param tokenAddress The address of the ERC-20 token to sweep\\n /// @param to The address to which tokens will be transferred\\n /// @param amount The amount to transfer\\n /// @custom:event Emits SweepToken event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\\n /// @custom:access Only Governance\\n function sweepToken(\\n address tokenAddress,\\n address to,\\n uint256 amount\\n ) external onlyOwner nonReentrant {\\n ensureNonzeroAddress(tokenAddress);\\n ensureNonzeroAddress(to);\\n ensureNonzeroValue(amount);\\n\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n preSweepToken(tokenAddress, amount);\\n token.safeTransfer(to, amount);\\n\\n emit SweepToken(tokenAddress, to, amount);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @notice The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n amountConvertedMantissa = amountInMantissa;\\n uint256 tokenInToOutConversion;\\n (amountOutMantissa, tokenInToOutConversion) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountConvertedMantissa = _divRoundingUp(maxTokenOutReserve * EXP_SCALE, tokenInToOutConversion);\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n\\n amountConvertedMantissa = amountOutMantissa;\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountOutMantissa, ) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountInMantissa;\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountOutMantissa;\\n }\\n\\n /// @notice This method updated the states of this contract after getting funds from PSR\\n /// after settling the amount(if any) through privateConversion between converters\\n /// @dev This function is called by protocolShareReserve\\n /// @dev call _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then\\n /// it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n function updateAssetsState(address comptroller, address asset) public nonReentrant {\\n uint256 balanceDiff = _updateAssetsState(comptroller, asset);\\n if (balanceDiff > 0) {\\n _privateConversion(comptroller, asset, balanceDiff);\\n }\\n }\\n\\n /// @notice Set the configuration for new or existing conversion pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n /// @custom:event Emits ConversionConfigUpdated event on success\\n /// @custom:error Unauthorized error is thrown when the call is not authorized by AccessControlManager\\n /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero\\n /// @custom:error NonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\\n /// @custom:access Controlled by AccessControlManager\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) public {\\n _checkAccessAllowed(\\\"setConversionConfig(address,address,ConversionConfig)\\\");\\n ensureNonzeroAddress(tokenAddressIn);\\n ensureNonzeroAddress(tokenAddressOut);\\n\\n if (conversionConfig.incentive > MAX_INCENTIVE) {\\n revert IncentiveTooHigh(conversionConfig.incentive, MAX_INCENTIVE);\\n }\\n\\n if (\\n (tokenAddressIn == tokenAddressOut) ||\\n (tokenAddressIn != _getDestinationBaseAsset()) ||\\n conversionConfigurations[tokenAddressOut][tokenAddressIn].conversionAccess != ConversionAccessibility.NONE\\n ) {\\n revert InvalidTokenConfigAddresses();\\n }\\n\\n if (\\n (conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) &&\\n conversionConfig.incentive != 0\\n ) {\\n revert NonZeroIncentiveForPrivateConversion();\\n }\\n\\n if (\\n ((conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) ||\\n (conversionConfig.conversionAccess == ConversionAccessibility.ALL)) &&\\n (address(converterNetwork) == address(0))\\n ) {\\n revert InvalidConverterNetwork();\\n }\\n\\n ConversionConfig storage configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n emit ConversionConfigUpdated(\\n tokenAddressIn,\\n tokenAddressOut,\\n configuration.incentive,\\n conversionConfig.incentive,\\n configuration.conversionAccess,\\n conversionConfig.conversionAccess\\n );\\n\\n if (conversionConfig.conversionAccess == ConversionAccessibility.NONE) {\\n delete conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n } else {\\n configuration.incentive = conversionConfig.incentive;\\n configuration.conversionAccess = conversionConfig.conversionAccess;\\n }\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) public view virtual returns (uint256 tokenBalance);\\n\\n /// @dev Operations to perform before sweeping tokens\\n /// @param token Address of the token\\n /// @param amount Amount transferred to address(to)\\n function preSweepToken(address token, uint256 amount) internal virtual {}\\n\\n /// @dev Converts exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return amountOutMantissa Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function _convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 amountOutMantissa) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, amountOutMantissa) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n if (amountOutMantissa < amountOutMinMantissa) {\\n revert AmountOutLowerThanMinRequired(amountOutMantissa, amountOutMinMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for exact amount of tokenAddressOut used for non deflationry tokens\\n /// it is called by convertForExactTokens function\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error DeflationaryTokenNotSupported is thrown if tokenAddressIn is deflationary token\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert DeflationaryTokenNotSupported();\\n }\\n\\n if (actualAmountIn > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n actualAmountOut = amountOutMantissa;\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for the amount of tokenAddressOut used for deflationary tokens\\n /// it is called by convertForExactTokensSupportingFeeOnTransferTokens function\\n /// @notice Advising users to input a smaller amountOutMantissa to avoid potential transaction revert\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n if (amountInMantissa > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, actualAmountOut) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n _doTransferOut(tokenAddressOut, to, actualAmountOut);\\n }\\n\\n /// @dev return actualAmountOut from reserves for tokenAddressOut\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred\\n /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n function _doTransferOut(\\n address tokenAddressOut,\\n address to,\\n uint256 amountConvertedMantissa\\n ) internal {\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountConvertedMantissa) {\\n revert InsufficientPoolLiquidity();\\n }\\n\\n _preTransferHook(tokenAddressOut, amountConvertedMantissa);\\n\\n IERC20Upgradeable tokenOut = IERC20Upgradeable(tokenAddressOut);\\n tokenOut.safeTransfer(to, amountConvertedMantissa);\\n }\\n\\n /// @notice Transfer tokenAddressIn from user to destination\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @return actualAmountIn Actual amount transferred to destination\\n function _doTransferIn(address tokenAddressIn, uint256 amountInMantissa) internal returns (uint256 actualAmountIn) {\\n IERC20Upgradeable tokenIn = IERC20Upgradeable(tokenAddressIn);\\n uint256 balanceBeforeDestination = tokenIn.balanceOf(destinationAddress);\\n tokenIn.safeTransferFrom(msg.sender, destinationAddress, amountInMantissa);\\n uint256 balanceAfterDestination = tokenIn.balanceOf(destinationAddress);\\n actualAmountIn = balanceAfterDestination - balanceBeforeDestination;\\n }\\n\\n /// @dev Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:event Emits PriceOracleUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero\\n function _setPriceOracle(ResilientOracle priceOracle_) internal {\\n ensureNonzeroAddress(address(priceOracle_));\\n emit PriceOracleUpdated(priceOracle, priceOracle_);\\n priceOracle = priceOracle_;\\n }\\n\\n /// @dev Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:event Emits DestinationAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when destination address is zero\\n function _setDestination(address destinationAddress_) internal {\\n ensureNonzeroAddress(destinationAddress_);\\n emit DestinationAddressUpdated(destinationAddress, destinationAddress_);\\n destinationAddress = destinationAddress_;\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:event Emits ConverterNetworkAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n function _setConverterNetwork(IConverterNetwork converterNetwork_) internal {\\n ensureNonzeroAddress(address(converterNetwork_));\\n emit ConverterNetworkAddressUpdated(address(converterNetwork), address(converterNetwork_));\\n converterNetwork = converterNetwork_;\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:event MinAmountToConvertUpdated is emitted in success\\n /// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\n function _setMinAmountToConvert(uint256 minAmountToConvert_) internal {\\n ensureNonzeroValue(minAmountToConvert_);\\n emit MinAmountToConvertUpdated(minAmountToConvert, minAmountToConvert_);\\n minAmountToConvert = minAmountToConvert_;\\n }\\n\\n /// @dev Hook to perform after converting tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param amountIn Amount of tokenIn converted\\n /// @param amountOut Amount of tokenOut converted\\n function _postConversionHook(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n ) internal virtual {}\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n __AccessControlled_init(accessControlManager_);\\n __ReentrancyGuard_init();\\n __AbstractTokenConverter_init_unchained(priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init_unchained(\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n _setPriceOracle(priceOracle_);\\n _setDestination(destinationAddress_);\\n _setMinAmountToConvert(minAmountToConvert_);\\n conversionPaused = false;\\n }\\n\\n /// @dev _updateAssetsState hook to update the states of reserves transferred for the specific comptroller\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n /// @return Amount of asset, for _privateConversion\\n function _updateAssetsState(address comptroller, address asset) internal virtual returns (uint256) {}\\n\\n /// @dev This method is used to convert asset into base asset by converting them with other converters which supports the pair and transfer the funds to\\n /// destination contract as destination's base asset\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset\\n /// @param amountToConvert Amount of the tokenAddressOut transferred to converter\\n function _privateConversion(\\n address comptroller,\\n address tokenAddressOut,\\n uint256 amountToConvert\\n ) internal {\\n address tokenAddressIn = _getDestinationBaseAsset();\\n address _destinationAddress = destinationAddress;\\n uint256 convertedTokenInBalance;\\n if (address(converterNetwork) != address(0)) {\\n (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork\\n .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn);\\n uint256 convertersLength = converterAddresses.length;\\n for (uint256 i; i < convertersLength; ) {\\n if (converterBalances[i] == 0) break;\\n (, uint256 amountIn) = IAbstractTokenConverter(converterAddresses[i]).getUpdatedAmountIn(\\n converterBalances[i],\\n tokenAddressOut,\\n tokenAddressIn\\n );\\n if (amountIn > amountToConvert) {\\n amountIn = amountToConvert;\\n }\\n\\n if (!_validateMinAmountToConvert(amountIn, tokenAddressOut)) {\\n break;\\n }\\n\\n uint256 balanceBefore = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n\\n IERC20Upgradeable(tokenAddressOut).forceApprove(converterAddresses[i], amountIn);\\n IAbstractTokenConverter(converterAddresses[i]).convertExactTokens(\\n amountIn,\\n 0,\\n tokenAddressOut,\\n tokenAddressIn,\\n _destinationAddress\\n );\\n\\n uint256 balanceAfter = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n amountToConvert -= amountIn;\\n convertedTokenInBalance += (balanceAfter - balanceBefore);\\n\\n if (amountToConvert == 0) break;\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n _postPrivateConversionHook(\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance,\\n tokenAddressOut,\\n amountToConvert\\n );\\n }\\n\\n /// @dev This hook is used to update states for the converter after the privateConversion\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressIn Address of the destination's base asset\\n /// @param convertedTokenInBalance Amount of the base asset received after the conversion\\n /// @param tokenAddressOut Address of the asset transferred to other converter in exchange of base asset\\n /// @param convertedTokenOutBalance Amount of tokenAddressOut transferred from this converter\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address tokenAddressOut,\\n uint256 convertedTokenOutBalance\\n ) internal virtual {}\\n\\n /// @notice This hook is used to update the state for asset reserves before transferring tokenOut to user\\n /// @param tokenOutAddress Address of the asset to be transferred to the user\\n /// @param amountOut Amount of tokenAddressOut transferred from this converter\\n function _preTransferHook(address tokenOutAddress, uint256 amountOut) internal virtual {}\\n\\n /// @dev Checks if amount to convert is greater than minimum amount to convert or not\\n /// @param amountIn The amount to convert\\n /// @param tokenAddress Address of the token\\n /// @return isValid true if amount to convert is greater than minimum amount to convert\\n function _validateMinAmountToConvert(uint256 amountIn, address tokenAddress) internal returns (bool isValid) {\\n priceOracle.updateAssetPrice(tokenAddress);\\n uint256 amountInInUsd = (priceOracle.getPrice(tokenAddress) * amountIn) / EXP_SCALE;\\n\\n if (amountInInUsd >= minAmountToConvert) {\\n isValid = true;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountOutMantissa, uint256 tokenInToOutConversion) {\\n if (amountInMantissa == 0) {\\n revert InsufficientInputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n if (address(converterNetwork) != address(0) && (converterNetwork.isTokenConverter(msg.sender))) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n /// amount of tokenAddressOut after including incentive as amountOutMantissa will be greater than actual as it gets\\n /// multiplied by conversionWithIncentive which will be >= 1\\n amountOutMantissa = (amountInMantissa * tokenInToOutConversion) / (EXP_SCALE);\\n }\\n\\n /// @dev To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @dev For user conversions, the function returns an amountInMantissa that is rounded up, ensuring that the equivalent amountInMantissa\\n /// is obtained from users for corresponding amountOutMantissa, preventing any losses to the protocol. However, no rounding up is required for private conversions\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountInMantissa, uint256 tokenInToOutConversion) {\\n if (amountOutMantissa == 0) {\\n revert InsufficientOutputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n\\n bool isPrivateConversion = address(converterNetwork) != address(0) &&\\n converterNetwork.isTokenConverter(msg.sender);\\n if (isPrivateConversion) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n /// amount of tokenAddressIn after considering incentive(i.e. amountInMantissa will be less than actual amountInMantissa if incentive > 0)\\n if (isPrivateConversion) {\\n amountInMantissa =\\n (amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE) /\\n (tokenInUnderlyingPrice * conversionWithIncentive);\\n } else {\\n amountInMantissa = _divRoundingUp(\\n amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE,\\n tokenInUnderlyingPrice * conversionWithIncentive\\n );\\n }\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n }\\n\\n /// @dev Check if msg.sender is allowed to convert as per onlyForPrivateConversions flag\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function _checkPrivateConversion(address tokenAddressIn, address tokenAddressOut) internal view {\\n bool isConverter = (address(converterNetwork) != address(0)) && converterNetwork.isTokenConverter(msg.sender);\\n if (\\n (!(isConverter) &&\\n (conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS))\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n }\\n\\n /// @dev To check, is conversion paused\\n /// @custom:error ConversionTokensPaused is thrown when token conversion is paused\\n function _checkConversionPaused() internal view {\\n if (conversionPaused) {\\n revert ConversionTokensPaused();\\n }\\n }\\n\\n /// @dev Get base asset address of the destination contract\\n /// @return Address of the base asset\\n function _getDestinationBaseAsset() internal view virtual returns (address) {}\\n\\n /// @dev Performs division where the result is rounded up\\n /// @param numerator The numerator of the division operation\\n /// @param denominator The denominator of the division operation. Must be non-zero\\n /// @return The result of the division, rounded up\\n function _divRoundingUp(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\\n return (numerator + denominator - 1) / denominator;\\n }\\n}\\n\",\"keccak256\":\"0xf87680dcb5a46a16663923c575661eda78ef57d29b7d78a85ddac00062426e18\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/IAbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @notice Interface for AbstractTokenConverter\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ninterface IAbstractTokenConverter {\\n /// @notice This enum define the all possible ways of conversion can happen\\n enum ConversionAccessibility {\\n NONE, // Conversion is disable for the pair\\n ALL, // Conversion is enable for private conversion and users\\n ONLY_FOR_CONVERTERS, // Conversion is enable only for private conversion\\n ONLY_FOR_USERS // Conversion is enable only for users\\n }\\n\\n /// @notice This struct represents the configuration for a token conversion.\\n struct ConversionConfig {\\n /// incentive on conversion of tokens in mantissa i.e 10% incentive would be 0.1 * 1e18\\n uint256 incentive;\\n /// enable or disable conversion for users or converters or both or none\\n ConversionAccessibility conversionAccess;\\n }\\n\\n /// @notice Pause conversion of tokens\\n function pauseConversion() external;\\n\\n /// @notice Resume conversion of tokens.\\n function resumeConversion() external;\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n function setPriceOracle(ResilientOracle priceOracle_) external;\\n\\n /// @notice Set the configuration for new or existing convert pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) external;\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Get the configuration for the pair of the tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return incentives Percentage of incentives to be distributed for the pair of tokens\\n /// @return conversionAccess Accessibility for the pair of tokens\\n function conversionConfigurations(address tokenAddressIn, address tokenAddressOut)\\n external\\n returns (uint256 incentives, ConversionAccessibility conversionAccess);\\n\\n /// @notice Get the address of the converterNetwork\\n function converterNetwork() external returns (IConverterNetwork converterNetwork);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) external view returns (uint256 tokenBalance);\\n}\\n\",\"keccak256\":\"0x7852d4f8a6dd1c80d14342f8ff2e26f723eb00c888e9a9e50a5fe8f95c59200c\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/SingleTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\n\\nimport { AbstractTokenConverter } from \\\"./AbstractTokenConverter.sol\\\";\\n\\n/// @title SingleTokenConverter\\n/// @author Venus\\n/// @notice SingleTokenConverter used for token conversions and sends received tokens\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ncontract SingleTokenConverter is AbstractTokenConverter {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Address of the base asset token\\n address public baseAsset;\\n\\n /// @notice The mapping contains the assets which are sent to destination directly\\n /// @dev Asset -> bool(should transfer directly on true)\\n mapping(address => bool) public assetsDirectTransfer;\\n\\n /// @notice Emitted when base asset is updated\\n event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset);\\n\\n /// @notice Emmitted after the funds transferred to the destination address\\n event AssetTransferredToDestination(\\n address indexed receiver,\\n address indexed comptroller,\\n address indexed asset,\\n uint256 amount\\n );\\n\\n /// @notice Emitted after the assetsDirectTransfer mapping is updated\\n event AssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value);\\n\\n /// @notice Thrown when the base asset is the same as the new base asset\\n error SameBaseAssetNotAllowed();\\n\\n /// @notice Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection\\n error DirectTransferBaseAssetNotAllowed();\\n\\n /// @notice Thrown when the `assetsDirectTransfer[asset]` is already `value`\\n /// @param asset The asset address whose `assetDirectTransfer` value went to be set\\n /// @param value The value to be set\\n error SameAssetDirectTransferNotAllowed(address asset, bool value);\\n\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor() {\\n // Note that the contract is upgradeable. Use initialize() or reinitializers\\n // to set the state variables.\\n _disableInitializers();\\n }\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param baseAsset_ Address of the base asset\\n /// @param minAmountToConvert_ Minimum amount to convert\\n function initialize(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n address baseAsset_,\\n uint256 minAmountToConvert_\\n ) public initializer {\\n _setBaseAsset(baseAsset_);\\n\\n // Initialize AbstractTokenConverter\\n __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @notice Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\\n /// @custom:event BaseAssetUpdated is emitted on success\\n /// @custom:access Only Governance\\n function setBaseAsset(address baseAsset_) external onlyOwner {\\n _setBaseAsset(baseAsset_);\\n }\\n\\n /// @notice Update the assetsDirectTransfer mapping\\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\\n /// @custom:event AssetsDirectTransferUpdated emits on success\\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\\n /// @custom:access Restricted by ACM\\n function setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) external virtual {\\n _checkAccessAllowed(\\\"setAssetsDirectTransfer(address[],bool[])\\\");\\n _setAssetsDirectTransfer(assets, values);\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param tokenAddress Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n tokenBalance = token.balanceOf(address(this));\\n }\\n\\n /// @dev It returns the balance of the `asset` in this contract. If `asset` is the `baseAsset`\\n /// or `assetsDirectTransfer[asset]` is true, then the balance of `asset` in this contract will\\n /// be transferred to the `destinationAddress` and 0 will be returned\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address.\\n /// @return balanceLeft Amount of asset, for _privateConversion\\n function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) {\\n IERC20Upgradeable token = IERC20Upgradeable(asset);\\n uint256 balance = token.balanceOf(address(this));\\n balanceLeft = balance;\\n\\n if (asset == baseAsset || assetsDirectTransfer[asset]) {\\n balanceLeft = 0;\\n token.safeTransfer(destinationAddress, balance);\\n emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance);\\n }\\n }\\n\\n /// @notice Hook called after a private conversion is completed\\n /// @dev Emits an AssetTransferredToDestination event if Private Conversion happens\\n /// @param comptroller The address of the comptroller (pool) associated with the conversion\\n /// @param tokenAddressIn The address of the input token that was converted\\n /// @param convertedTokenInBalance The amount of input token that was converted\\n /// @custom:event AssetTransferredToDestination Emitted when convertedTokenInBalance > 0, indicating\\n /// the converted assets were transferred to the destination address\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address,\\n uint256\\n ) internal override {\\n if (convertedTokenInBalance > 0) {\\n emit AssetTransferredToDestination(\\n destinationAddress,\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance\\n );\\n }\\n }\\n\\n /// @dev Update the assetsDirectTransfer mapping for destinationAddress\\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\\n /// @custom:event AssetsDirectTransferUpdated emits on success\\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\\n /// @custom:error DirectTransferBaseAssetNotAllowed thrown when an asset in `assets` is the `baseAsset`\\n /// @custom:error SameAssetDirectTransferNotAllowed thrown when the value to set for an asset doesn't differs\\n /// from its current value\\n function _setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) internal {\\n uint256 assetsLength = assets.length;\\n\\n if (assetsLength != values.length) {\\n revert InputLengthMisMatch();\\n }\\n\\n for (uint256 i; i < assetsLength; ++i) {\\n if (assets[i] == baseAsset) {\\n revert DirectTransferBaseAssetNotAllowed();\\n }\\n\\n if (assetsDirectTransfer[assets[i]] == values[i]) {\\n revert SameAssetDirectTransferNotAllowed(assets[i], values[i]);\\n }\\n\\n assetsDirectTransfer[assets[i]] = values[i];\\n emit AssetsDirectTransferUpdated(destinationAddress, assets[i], values[i]);\\n }\\n }\\n\\n /// @dev Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\\n /// @custom:event BaseAssetUpdated is emitted on success\\n function _setBaseAsset(address baseAsset_) internal {\\n ensureNonzeroAddress(baseAsset_);\\n\\n if (baseAsset == baseAsset_) {\\n revert SameBaseAssetNotAllowed();\\n }\\n\\n emit BaseAssetUpdated(baseAsset, baseAsset_);\\n baseAsset = baseAsset_;\\n }\\n\\n /// @dev Get base asset address\\n /// @return destinationBaseAsset Address of the base asset(baseAsset)\\n function _getDestinationBaseAsset() internal view override returns (address destinationBaseAsset) {\\n destinationBaseAsset = baseAsset;\\n }\\n}\\n\",\"keccak256\":\"0x3358796675c9c556ce90143ed762f7f2ed3ce46a5faeaf3d99574b0ba134cfac\",\"license\":\"BSD-3-Clause\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106102925760003560e01c80638da5cb5b11610160578063cd2960b7116100d8578063f04c31871161008c578063f2fde38b11610071578063f2fde38b146105a0578063f7013ef6146105b3578063fe3da984146105c657600080fd5b8063f04c31871461057a578063f0dc7e9d1461058d57600080fd5b8063d1451e28116100bd578063d1451e2814610547578063e2ff7ea21461055a578063e30c39781461056957600080fd5b8063cd2960b71461050f578063cdf456e11461053357600080fd5b8063b4a0bdf31161012f578063bc368b0411610114578063bc368b04146104e1578063c0654646146104e9578063ca325469146104fc57600080fd5b8063b4a0bdf3146104bd578063b6828c57146104ce57600080fd5b80638da5cb5b1461044357806390fa7b5414610454578063aac59a7514610467578063b491ddf71461047a57600080fd5b8063530e784f1161020e5780636f1a30a8116101c2578063715018a6116101a7578063715018a614610420578063746460a91461042857806379ba50971461043b57600080fd5b80636f1a30a8146103ec57806370a08231146103ff57600080fd5b80635e1e6325116101f35780635e1e6325146103b357806364aff9ec146103c65780636daa463b146103d957600080fd5b8063530e784f1461039857806358b904df146103ab57600080fd5b80630e32cb86116102655780633606b26c1161024a5780633606b26c1461035f578063439727a51461037257806352e21a181461038557600080fd5b80630e32cb86146103395780632630c12f1461034c57600080fd5b806301e201781461029757806307aa239e146102c75780630a0a05e6146102fc5780630a9a2b7214610311575b600080fd5b60ff546102aa906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b60fe546102ec9074010000000000000000000000000000000000000000900460ff1681565b60405190151581526020016102be565b61030f61030a366004613db9565b6105cf565b005b61032461031f366004613dd6565b6105e3565b604080519283526020830191909152016102be565b61030f610347366004613db9565b610691565b60fc546102aa906001600160a01b031681565b61030f61036d366004613db9565b6106a2565b610324610380366004613e18565b6106b3565b61030f610393366004613db9565b6107f1565b61030f6103a6366004613db9565b610802565b61030f610813565b6103246103c1366004613dd6565b6108f9565b61030f6103d4366004613e77565b6109c7565b6103246103e7366004613dd6565b610a64565b6103246103fa366004613dd6565b610b6d565b61041261040d366004613db9565b610c6c565b6040519081526020016102be565b61030f610cf9565b61030f610436366004613eb8565b610d0d565b61030f610d54565b6033546001600160a01b03166102aa565b610324610462366004613e18565b610de4565b61030f610475366004613ed1565b610ece565b6104af610488366004613ed1565b60fd6020908152600092835260408084209091529082529020805460019091015460ff1682565b6040516102be929190613f74565b6097546001600160a01b03166102aa565b6103246104dc366004613e18565b610f04565b61030f610fee565b61030f6104f7366004613fd4565b6110a0565b60fe546102aa906001600160a01b031681565b6102ec61051d366004613db9565b61012e6020526000908152604090205460ff1681565b61012d546102aa906001600160a01b031681565b61030f610555366004614084565b61113e565b6104126706f05b59d3b2000081565b6065546001600160a01b03166102aa565b610324610588366004613e18565b611171565b61030f61059b3660046140f0565b611294565b61030f6105ae366004613db9565b611632565b61030f6105c1366004614161565b6116bb565b61041260fb5481565b6105d7611845565b6105e08161189f565b50565b60008060026001600160a01b03808616600090815260fd602090815260408083209388168352929052206001015460ff16600381111561062557610625613f0a565b0361065c576040517f03410cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600061066784610c6c565b905085811015610675578095505b85925061068386868661191c565b508092505050935093915050565b610699611845565b6105e081611c82565b6106aa611845565b6105e081611d77565b6000808285856106c1611e3e565b6106ca83611e93565b816001600160a01b0316836001600160a01b031614806106fb5750806001600160a01b0316836001600160a01b0316145b15610732576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61073a611ed3565b6107478a8a8a8a8a611f2c565b9095509350898514610785576040517fc214279600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604080516001600160a01b038a81168252602082018890529181018690528189169188169033907f795a235be939acb902ac69562805f86e1341a9b019c351b996e2aa2dfc34c67c906060015b60405180910390a46107e4600160c955565b5050509550959350505050565b6107f9611845565b6105e081611fb3565b61080a611845565b6105e081612030565b6108516040518060400160405280601281526020017f726573756d65436f6e76657273696f6e282900000000000000000000000000008152506120ad565b60fe5474010000000000000000000000000000000000000000900460ff166108a4576040517e6d8dbb00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fe80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff16905560405133907f89b79206f08dadd78502cff5075d2b094fa0abea0b063cfafe4475e2a380c51f90600090a2565b60008060026001600160a01b03808616600090815260fd602090815260408083209388168352929052206001015460ff16600381111561093b5761093b613f0a565b03610972576040517f03410cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8491506000610982868686612179565b9092509050600061099285610c6c565b9050828110156109bd576109b76109b1670de0b6b3a7640000836141f4565b83612486565b93508092505b5050935093915050565b6109cf611845565b6109d7611ed3565b6109e083611e93565b6109e982611e93565b6109f2816124b2565b82610a076001600160a01b03821684846124ec565b826001600160a01b0316846001600160a01b03167f6d25be279134f4ecaa4770aff0c3d916d9e7c5ef37b65ed95dbdba411f5d54d584604051610a4c91815260200190565b60405180910390a350610a5f600160c955565b505050565b60fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038481166004830152600092839291169063b62cad6990602401600060405180830381600087803b158015610ac857600080fd5b505af1158015610adc573d6000803e3d6000fd5b505060fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038781166004830152909116925063b62cad699150602401600060405180830381600087803b158015610b4057600080fd5b505af1158015610b54573d6000803e3d6000fd5b50505050610b63858585612179565b5094959350505050565b60fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038481166004830152600092839291169063b62cad6990602401600060405180830381600087803b158015610bd157600080fd5b505af1158015610be5573d6000803e3d6000fd5b505060fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038781166004830152909116925063b62cad699150602401600060405180830381600087803b158015610c4957600080fd5b505af1158015610c5d573d6000803e3d6000fd5b50505050610b6385858561191c565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015260009082906001600160a01b038216906370a0823190602401602060405180830381865afa158015610cce573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610cf2919061420b565b9392505050565b610d01611845565b610d0b60006125b3565b565b610d4b6040518060400160405280601e81526020017f7365744d696e416d6f756e74546f436f6e766572742875696e743235362900008152506120ad565b6105e0816125e4565b60655433906001600160a01b03168114610ddb5760405162461bcd60e51b815260206004820152602960248201527f4f776e61626c6532537465703a2063616c6c6572206973206e6f74207468652060448201527f6e6577206f776e6572000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b6105e0816125b3565b600080828585610df2611e3e565b610dfb83611e93565b816001600160a01b0316836001600160a01b03161480610e2c5750806001600160a01b0316836001600160a01b0316145b15610e63576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610e6b611ed3565b610e788a8a8a8a8a611f2c565b9095509350604080516001600160a01b038a81168252602082018890529181018690528189169188169033907f93b7ba2a2b0e36320375853d7466af5685c07567804b871b4fdfd31e3bb77154906060016107d2565b610ed6611ed3565b6000610ee2838361262e565b90508015610ef557610ef5838383612767565b50610f00600160c955565b5050565b600080828585610f12611e3e565b610f1b83611e93565b816001600160a01b0316836001600160a01b03161480610f4c5750806001600160a01b0316836001600160a01b0316145b15610f83576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610f8b611ed3565b610f988a8a8a8a8a612bc4565b9095509350604080516001600160a01b038a81168252602082018890529181018690528189169188169033907f9b7dc1d7d2974d015b4fc39889a09f3a3923add808f5863158f3162d997d4e82906060016107d2565b61102c6040518060400160405280601181526020017f7061757365436f6e76657273696f6e28290000000000000000000000000000008152506120ad565b611034611e3e565b60fe80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000017905560405133907f490bc639fd0d96f19c8adf77bc98d17fbefdee2e1e1864d21f041360d0ee065a90600090a2565b828181146110da576040517f4d5590f300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60005b818110156111355761112d878787848181106110fb576110fb614224565b90506020020160208101906111109190613db9565b86868581811061112257611122614224565b905060400201611294565b6001016110dd565b50505050505050565b61115f604051806060016040528060298152602001614660602991396120ad565b61116b84848484612c56565b50505050565b60008082858561117f611e3e565b61118883611e93565b816001600160a01b0316836001600160a01b031614806111b95750806001600160a01b0316836001600160a01b0316145b156111f0576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6111f8611ed3565b6112058a8a8a8a8a612f4e565b9095509350888414611243576040517fa8dc653c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604080516001600160a01b038a81168252602082018890529181018690528189169188169033907fcb4ea7de8d069b0f443b792cba6c6df5096508951bbc75c04ac42c9251efe076906060016107d2565b6112b560405180606001604052806035815260200161462b603591396120ad565b6112be83611e93565b6112c782611e93565b6706f05b59d3b200008135111561131b576040517f9770caee000000000000000000000000000000000000000000000000000000008152813560048201526706f05b59d3b200006024820152604401610dd2565b816001600160a01b0316836001600160a01b0316148061134a575061012d546001600160a01b03848116911614155b80611392575060006001600160a01b03808416600090815260fd602090815260408083209388168352929052206001015460ff16600381111561138f5761138f613f0a565b14155b156113c9576040517feebb5ac600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60026113db6040830160208401614253565b60038111156113ec576113ec613f0a565b1480156113f95750803515155b15611430576040517fd0d4aabe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60026114426040830160208401614253565b600381111561145357611453613f0a565b148061147f5750600161146c6040830160208401614253565b600381111561147d5761147d613f0a565b145b8015611494575060ff546001600160a01b0316155b156114cb576040517fe7c2c99400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b03808416600081815260fd602090815260408083209487168084529482529182902080546001820154919594937f39fbfdd5da133303ed31b1b65e30a0ddf7a9236573368c66c859dceccc1dd12a93919288359260ff9091169161153b91908a01908a01614253565b60405161154b9493929190614274565b60405180910390a360006115656040840160208501614253565b600381111561157657611576613f0a565b036115d3576001600160a01b03808516600090815260fd60209081526040808320938716835292905290812090815560010180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016905561116b565b813581556115e76040830160208401614253565b6001808301805490917fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff009091169083600381111561162757611627613f0a565b021790555050505050565b61163a611845565b606580546001600160a01b0383167fffffffffffffffffffffffff000000000000000000000000000000000000000090911681179091556116836033546001600160a01b031690565b6001600160a01b03167f38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e2270060405160405180910390a350565b600054610100900460ff16158080156116db5750600054600160ff909116105b806116f55750303b1580156116f5575060005460ff166001145b6117675760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a65640000000000000000000000000000000000006064820152608401610dd2565b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016600117905580156117c557600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b6117ce83611d77565b6117da8686868561300b565b801561183d57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b505050505050565b6033546001600160a01b03163314610d0b5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610dd2565b6118a881611e93565b60fe546040516001600160a01b038084169216907f9be3097b5c8b276786be52a244ee90d66efd34805d9eb16f168fb2b4aaae9a2b90600090a360fe80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b60008084600003611959576040517f42301c2300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b03808516600090815260fd6020908152604080832093871683529281528282208351808501909452805484526001810154929392909183019060ff1660038111156119ad576119ad613f0a565b60038111156119be576119be613f0a565b90525090506000816020015160038111156119db576119db613f0a565b03611a12576040517f618ce59700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483015260009216906341976e0990602401602060405180830381865afa158015611a76573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611a9a919061420b565b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b038881166004830152929350600092909116906341976e0990602401602060405180830381865afa158015611b03573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b27919061420b565b835160ff54919250906000906001600160a01b031615801590611bca575060ff546040517f6c059fb10000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b0390911690636c059fb190602401602060405180830381865afa158015611ba6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611bca91906142aa565b90508015611bd757600091505b6000611beb83670de0b6b3a76400006142c7565b90508115611c2b57611bfd81866141f4565b670de0b6b3a7640000611c10868e6141f4565b611c1a91906141f4565b611c2491906142da565b9750611c5d565b611c5a670de0b6b3a7640000611c41868e6141f4565b611c4b91906141f4565b611c5583886141f4565b612486565b97505b83611c6882876141f4565b611c7291906142da565b9650505050505050935093915050565b6001600160a01b038116611cfe5760405162461bcd60e51b815260206004820152602560248201527f696e76616c696420616365737320636f6e74726f6c206d616e6167657220616460448201527f64726573730000000000000000000000000000000000000000000000000000006064820152608401610dd2565b609780546001600160a01b038381167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604080519190921680825260208201939093527f66fd58e82f7b31a2a5c30e0888f3093efe4e111b00cd2b0c31fe014601293aa0910160405180910390a15050565b611d8081611e93565b61012d546001600160a01b03808316911603611dc8576040517f29db101000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61012d546040516001600160a01b038084169216907f4fe44995ca2482562846e3c0413d9bd6147e9ce1881c66a8765e8542fef99f4290600090a361012d80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b60fe5474010000000000000000000000000000000000000000900460ff1615610d0b576040517f952bcf7f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b0381166105e0576040517f8579befe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600260c95403611f255760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610dd2565b600260c955565b600080611f3985856130a4565b611f4385886131c4565b9150611f50828686610a64565b91505085811015611f97576040517f228f8c110000000000000000000000000000000000000000000000000000000081526004810182905260248101879052604401610dd2565b611fa284848361330f565b9550959350505050565b600160c955565b611fbc81611e93565b60ff546040516001600160a01b038084169216907f50f1a16bf24734355b14ff800d132cc0a934808b8621d5623b41bc67f204881790600090a360ff80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b61203981611e93565b60fc546040516001600160a01b038084169216907f56b5f80d8cac1479698aa7d01605fd6111e90b15fc4d2b377417f46034876cbd90600090a360fc80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b6097546040517f18c5e8ab0000000000000000000000000000000000000000000000000000000081526000916001600160a01b0316906318c5e8ab906120f99033908690600401614383565b602060405180830381865afa158015612116573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061213a91906142aa565b905080610f00573330836040517f4a3fa293000000000000000000000000000000000000000000000000000000008152600401610dd2939291906143a5565b600080846000036121b6576040517f098fb56100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b03808516600090815260fd6020908152604080832093871683529281528282208351808501909452805484526001810154929392909183019060ff16600381111561220a5761220a613f0a565b600381111561221b5761221b613f0a565b905250905060008160200151600381111561223857612238613f0a565b0361226f576040517f618ce59700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483015260009216906341976e0990602401602060405180830381865afa1580156122d3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906122f7919061420b565b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b038881166004830152929350600092909116906341976e0990602401602060405180830381865afa158015612360573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612384919061420b565b835160ff54919250906001600160a01b031615801590612424575060ff546040517f6c059fb10000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b0390911690636c059fb190602401602060405180830381865afa158015612400573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061242491906142aa565b1561242d575060005b600061244182670de0b6b3a76400006142c7565b90508261244e82866141f4565b61245891906142da565b9550670de0b6b3a764000061246d878c6141f4565b61247791906142da565b96505050505050935093915050565b600081600161249582866142c7565b61249f91906143d1565b6124a991906142da565b90505b92915050565b806000036105e0576040517f9cf8540c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040516001600160a01b038316602482015260448101829052610a5f9084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064015b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090931692909217909152613372565b606580547fffffffffffffffffffffffff00000000000000000000000000000000000000001690556105e08161345a565b6125ed816124b2565b60fb5460408051918252602082018390527fada67d0d38fa20c8ae6a5c17cb9d60b0fe7f2d4e4f27ac9ee55e54ac88de9d8d910160405180910390a160fb55565b6040517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152600090829082906001600160a01b038316906370a0823190602401602060405180830381865afa158015612692573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906126b6919061420b565b61012d549093508391506001600160a01b03858116911614806126f257506001600160a01b038416600090815261012e602052604090205460ff165b1561275f5760fe5460009350612715906001600160a01b038481169116836124ec565b60fe546040518281526001600160a01b0386811692888216929116907fadc20ad416881f76b4304665c35f5be8592297bcdfe4f0bb087b9d254222af559060200160405180910390a45b505092915050565b600061277c61012d546001600160a01b031690565b60fe5460ff549192506001600160a01b03908116916000911615612bb75760ff546040517f4e9f8f390000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483015285811660248301526000928392911690634e9f8f39906044016000604051808303816000875af115801561280b573d6000803e3d6000fd5b505050506040513d6000823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016820160405261285191908101906144f5565b8151919350915060005b81811015612bb25782818151811061287557612875614224565b602002602001015160000315612bb257600084828151811061289957612899614224565b60200260200101516001600160a01b0316636f1a30a88584815181106128c1576128c1614224565b60200260200101518c8b6040518463ffffffff1660e01b8152600401612903939291909283526001600160a01b03918216602084015216604082015260600190565b60408051808303816000875af1158015612921573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061294591906145ba565b915050888111156129535750875b61295d818b6134c4565b6129675750612bb2565b6040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b038881166004830152600091908a16906370a0823190602401602060405180830381865afa1580156129ca573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129ee919061420b565b9050612a27868481518110612a0557612a05614224565b6020026020010151838d6001600160a01b03166135fc9092919063ffffffff16565b858381518110612a3957612a39614224565b60209081029190910101516040517f439727a500000000000000000000000000000000000000000000000000000000815260048101849052600060248201526001600160a01b038d811660448301528b811660648301528a811660848301529091169063439727a59060a40160408051808303816000875af1158015612ac3573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612ae791906145ba565b50506040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b038981166004830152600091908b16906370a0823190602401602060405180830381865afa158015612b4c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612b70919061420b565b9050612b7c838c6143d1565b9a50612b8882826143d1565b612b9290896142c7565b97508a600003612ba457505050612bb2565b83600101935050505061285b565b505050505b61183d86848388886136d2565b600080612bd185856130a4565b6000612bde878787610b6d565b91505087811115612c25576040517f71b5f0c10000000000000000000000000000000000000000000000000000000081526004810182905260248101899052604401610dd2565b612c2f86826131c4565b9250612c3c838787610a64565b9250612c4b905085858461330f565b509550959350505050565b82818114612c90576040517f4d5590f300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60005b8181101561183d5761012d546001600160a01b0316868683818110612cba57612cba614224565b9050602002016020810190612ccf9190613db9565b6001600160a01b031603612d0f576040517f7b3db9df00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b838382818110612d2157612d21614224565b9050602002016020810190612d3691906145de565b151561012e6000888885818110612d4f57612d4f614224565b9050602002016020810190612d649190613db9565b6001600160a01b0316815260208101919091526040016000205460ff16151503612e1b57858582818110612d9a57612d9a614224565b9050602002016020810190612daf9190613db9565b848483818110612dc157612dc1614224565b9050602002016020810190612dd691906145de565b6040517fb7d7b07b0000000000000000000000000000000000000000000000000000000081526001600160a01b03909216600483015215156024820152604401610dd2565b838382818110612e2d57612e2d614224565b9050602002016020810190612e4291906145de565b61012e6000888885818110612e5957612e59614224565b9050602002016020810190612e6e9190613db9565b6001600160a01b03168152602081019190915260400160002080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016911515919091179055858582818110612ec657612ec6614224565b9050602002016020810190612edb9190613db9565b60fe546001600160a01b0391821691167ffaf87441caeefee3e3093a251df3fad79b58529016ff418f84baffa3a10b4199868685818110612f1e57612f1e614224565b9050602002016020810190612f3391906145de565b604051901515815260200160405180910390a3600101612c93565b600080612f5b85856130a4565b6000612f68878787610b6d565b915050612f7586826131c4565b9250808314612fb0576040517f0c5c1c2000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b87831115612ff4576040517f71b5f0c10000000000000000000000000000000000000000000000000000000081526004810182905260248101899052604401610dd2565b612fff85858961330f565b50909694955050505050565b600054610100900460ff166130885760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610dd2565b61309184613728565b6130996137b6565b61116b83838361383b565b60ff546000906001600160a01b031615801590613141575060ff546040517f6c059fb10000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b0390911690636c059fb190602401602060405180830381865afa15801561311d573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061314191906142aa565b90508015801561318d575060026001600160a01b03808516600090815260fd602090815260408083209387168352929052206001015460ff16600381111561318b5761318b613f0a565b145b15610a5f576040517f03410cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fe546040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b039182166004820152600091849183918316906370a0823190602401602060405180830381865afa15801561322d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190613251919061420b565b60fe54909150613270906001600160a01b038481169133911687613900565b60fe546040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b0391821660048201526000918416906370a0823190602401602060405180830381865afa1580156132d5573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906132f9919061420b565b905061330582826143d1565b9695505050505050565b600061331a84610c6c565b905081811015613356576040517f6bb2792900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8361336b6001600160a01b03821685856124ec565b5050505050565b60006133c7826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166139519092919063ffffffff16565b90508051600014806133e85750808060200190518101906133e891906142aa565b610a5f5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610dd2565b603380546001600160a01b038381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038381166004830152600092169063b62cad6990602401600060405180830381600087803b15801561352557600080fd5b505af1158015613539573d6000803e3d6000fd5b505060fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b03868116600483015260009450670de0b6b3a76400009350879216906341976e0990602401602060405180830381865afa1580156135ad573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906135d1919061420b565b6135db91906141f4565b6135e591906142da565b905060fb5481106135f557600191505b5092915050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f095ea7b30000000000000000000000000000000000000000000000000000000017905261367b8482613968565b61116b576040516001600160a01b0384166024820152600060448201526136c89085907f095ea7b30000000000000000000000000000000000000000000000000000000090606401612531565b61116b8482613372565b821561336b5760fe546040518481526001600160a01b0386811692888216929116907fadc20ad416881f76b4304665c35f5be8592297bcdfe4f0bb087b9d254222af559060200160405180910390a45050505050565b600054610100900460ff166137a55760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610dd2565b6137ad613a0f565b6105e081613a94565b600054610100900460ff166138335760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610dd2565b610d0b613b11565b600054610100900460ff166138b85760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610dd2565b6138c183612030565b6138ca8261189f565b6138d3816125e4565b505060fe80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff16905550565b6040516001600160a01b038085166024830152831660448201526064810182905261116b9085907f23b872dd0000000000000000000000000000000000000000000000000000000090608401612531565b60606139608484600085613b8e565b949350505050565b6000806000846001600160a01b03168460405161398591906145fb565b6000604051808303816000865af19150503d80600081146139c2576040519150601f19603f3d011682016040523d82523d6000602084013e6139c7565b606091505b50915091508180156139f15750805115806139f15750808060200190518101906139f191906142aa565b8015613a0657506001600160a01b0385163b15155b95945050505050565b600054610100900460ff16613a8c5760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610dd2565b610d0b613c80565b600054610100900460ff166106995760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610dd2565b600054610100900460ff16611fac5760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610dd2565b606082471015613c065760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610dd2565b600080866001600160a01b03168587604051613c2291906145fb565b60006040518083038185875af1925050503d8060008114613c5f576040519150601f19603f3d011682016040523d82523d6000602084013e613c64565b606091505b5091509150613c7587838387613d06565b979650505050505050565b600054610100900460ff16613cfd5760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610dd2565b610d0b336125b3565b60608315613d75578251600003613d6e576001600160a01b0385163b613d6e5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610dd2565b5081613960565b6139608383815115613d8a5781518083602001fd5b8060405162461bcd60e51b8152600401610dd29190614617565b6001600160a01b03811681146105e057600080fd5b600060208284031215613dcb57600080fd5b8135610cf281613da4565b600080600060608486031215613deb57600080fd5b833592506020840135613dfd81613da4565b91506040840135613e0d81613da4565b809150509250925092565b600080600080600060a08688031215613e3057600080fd5b85359450602086013593506040860135613e4981613da4565b92506060860135613e5981613da4565b91506080860135613e6981613da4565b809150509295509295909350565b600080600060608486031215613e8c57600080fd5b8335613e9781613da4565b92506020840135613ea781613da4565b929592945050506040919091013590565b600060208284031215613eca57600080fd5b5035919050565b60008060408385031215613ee457600080fd5b8235613eef81613da4565b91506020830135613eff81613da4565b809150509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b60048110613f70577f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b9052565b82815260408101610cf26020830184613f39565b60008083601f840112613f9a57600080fd5b50813567ffffffffffffffff811115613fb257600080fd5b6020830191508360208260051b8501011115613fcd57600080fd5b9250929050565b600080600080600060608688031215613fec57600080fd5b8535613ff781613da4565b9450602086013567ffffffffffffffff8082111561401457600080fd5b61402089838a01613f88565b9096509450604088013591508082111561403957600080fd5b818801915088601f83011261404d57600080fd5b81358181111561405c57600080fd5b8960208260061b850101111561407157600080fd5b9699959850939650602001949392505050565b6000806000806040858703121561409a57600080fd5b843567ffffffffffffffff808211156140b257600080fd5b6140be88838901613f88565b909650945060208701359150808211156140d757600080fd5b506140e487828801613f88565b95989497509550505050565b6000806000838503608081121561410657600080fd5b843561411181613da4565b9350602085013561412181613da4565b925060407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc08201121561415357600080fd5b506040840190509250925092565b600080600080600060a0868803121561417957600080fd5b853561418481613da4565b9450602086013561419481613da4565b935060408601356141a481613da4565b925060608601356141b481613da4565b949793965091946080013592915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b80820281158282048414176124ac576124ac6141c5565b60006020828403121561421d57600080fd5b5051919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60006020828403121561426557600080fd5b813560048110610cf257600080fd5b848152602081018490526080810161428f6040830185613f39565b613a066060830184613f39565b80151581146105e057600080fd5b6000602082840312156142bc57600080fd5b8151610cf28161429c565b808201808211156124ac576124ac6141c5565b600082614310577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b60005b83811015614330578181015183820152602001614318565b50506000910152565b60008151808452614351816020860160208601614315565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b6001600160a01b03831681526040602082015260006139606040830184614339565b60006001600160a01b03808616835280851660208401525060606040830152613a066060830184614339565b818103818111156124ac576124ac6141c5565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff8111828210171561445a5761445a6143e4565b604052919050565b600067ffffffffffffffff82111561447c5761447c6143e4565b5060051b60200190565b600082601f83011261449757600080fd5b815160206144ac6144a783614462565b614413565b8083825260208201915060208460051b8701019350868411156144ce57600080fd5b602086015b848110156144ea57805183529183019183016144d3565b509695505050505050565b6000806040838503121561450857600080fd5b825167ffffffffffffffff8082111561452057600080fd5b818501915085601f83011261453457600080fd5b815160206145446144a783614462565b82815260059290921b8401810191818101908984111561456357600080fd5b948201945b8386101561458a57855161457b81613da4565b82529482019490820190614568565b918801519196509093505050808211156145a357600080fd5b506145b085828601614486565b9150509250929050565b600080604083850312156145cd57600080fd5b505080516020909101519092909150565b6000602082840312156145f057600080fd5b8135610cf28161429c565b6000825161460d818460208701614315565b9190910192915050565b6020815260006124a9602083018461433956fe736574436f6e76657273696f6e436f6e66696728616464726573732c616464726573732c436f6e76657273696f6e436f6e666967297365744173736574734469726563745472616e7366657228616464726573735b5d2c626f6f6c5b5d29a2646970667358221220600656f7554286fef66062f7efdf895e97f82f5ce299d60b63e0eb82e2539a7164736f6c63430008190033", "devdoc": { "author": "Venus", "custom:security-contact": "https://github.com/VenusProtocol/protocol-reserve#discussion", + "errors": { + "SameAssetDirectTransferNotAllowed(address,bool)": [ + { + "params": { + "asset": "The asset address whose `assetDirectTransfer` value went to be set", + "value": "The value to be set" + } + } + ] + }, "events": { "Initialized(uint8)": { "details": "Triggered when the contract has been initialized or reinitialized." @@ -1586,8 +1684,19 @@ "accessControlManager_": "The new address of the AccessControlManager" } }, + "setAssetsDirectTransfer(address[],bool[])": { + "custom:access": "Restricted by ACM", + "custom:error": "InputLengthMisMatch thrown when assets and values array lengths don't match", + "custom:event": "AssetsDirectTransferUpdated emits on success", + "params": { + "assets": "Addresses of the assets need to be added or removed for direct transfer", + "values": "Boolean value to indicate whether direct transfer is allowed for each asset." + } + }, "setBaseAsset(address)": { "custom:access": "Only Governance", + "custom:error": "ZeroAddressNotAllowed is thrown when address is zeroSameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset", + "custom:event": "BaseAssetUpdated is emitted on success", "params": { "baseAsset_": "The new address of the base asset" } @@ -1655,6 +1764,11 @@ } } }, + "stateVariables": { + "assetsDirectTransfer": { + "details": "Asset -> bool(should transfer directly on true)" + } + }, "title": "SingleTokenConverter", "version": 1 }, @@ -1705,6 +1819,11 @@ "notice": "Thrown when using convertForExactTokens deflationary tokens" } ], + "DirectTransferBaseAssetNotAllowed()": [ + { + "notice": "Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection" + } + ], "IncentiveTooHigh(uint256,uint256)": [ { "notice": "Thrown when incentive is higher than the MAX_INCENTIVE" @@ -1755,6 +1874,16 @@ "notice": "Thrown when trying to set non zero incentive for private conversion" } ], + "SameAssetDirectTransferNotAllowed(address,bool)": [ + { + "notice": "Thrown when the `assetsDirectTransfer[asset]` is already `value`" + } + ], + "SameBaseAssetNotAllowed()": [ + { + "notice": "Thrown when the base asset is the same as the new base asset" + } + ], "Unauthorized(address,address,string)": [ { "notice": "Thrown when the action is prohibited by AccessControlManager" @@ -1775,6 +1904,9 @@ "AssetTransferredToDestination(address,address,address,uint256)": { "notice": "Emmitted after the funds transferred to the destination address" }, + "AssetsDirectTransferUpdated(address,address,bool)": { + "notice": "Emitted after the assetsDirectTransfer mapping is updated" + }, "BaseAssetUpdated(address,address)": { "notice": "Emitted when base asset is updated" }, @@ -1826,6 +1958,9 @@ "accessControlManager()": { "notice": "Returns the address of the access control manager contract" }, + "assetsDirectTransfer(address)": { + "notice": "The mapping contains the assets which are sent to destination directly" + }, "balanceOf(address)": { "notice": "Get the balance for specific token" }, @@ -1883,6 +2018,9 @@ "setAccessControlManager(address)": { "notice": "Sets the address of AccessControlManager" }, + "setAssetsDirectTransfer(address[],bool[])": { + "notice": "Update the assetsDirectTransfer mapping" + }, "setBaseAsset(address)": { "notice": "Sets the base asset for the contract" }, @@ -2067,6 +2205,14 @@ "offset": 0, "slot": "301", "type": "t_address" + }, + { + "astId": 5318, + "contract": "contracts/TokenConverter/SingleTokenConverter.sol:SingleTokenConverter", + "label": "assetsDirectTransfer", + "offset": 0, + "slot": "302", + "type": "t_mapping(t_address,t_bool)" } ], "types": { @@ -2118,6 +2264,13 @@ "label": "enum IAbstractTokenConverter.ConversionAccessibility", "numberOfBytes": "1" }, + "t_mapping(t_address,t_bool)": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => bool)", + "numberOfBytes": "32", + "value": "t_bool" + }, "t_mapping(t_address,t_mapping(t_address,t_struct(ConversionConfig)5108_storage))": { "encoding": "mapping", "key": "t_address", diff --git a/deployments/bscmainnet/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json b/deployments/bscmainnet/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json new file mode 100644 index 00000000..774cd037 --- /dev/null +++ b/deployments/bscmainnet/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json @@ -0,0 +1,103 @@ +{ + "language": "Solidity", + "sources": { + "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./OwnableUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\n function __Ownable2Step_init() internal onlyInitializing {\n __Ownable_init_unchained();\n }\n\n function __Ownable2Step_init_unchained() internal onlyInitializing {\n }\n address private _pendingOwner;\n\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Returns the address of the pending owner.\n */\n function pendingOwner() public view virtual returns (address) {\n return _pendingOwner;\n }\n\n /**\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual override onlyOwner {\n _pendingOwner = newOwner;\n emit OwnershipTransferStarted(owner(), newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual override {\n delete _pendingOwner;\n super._transferOwnership(newOwner);\n }\n\n /**\n * @dev The new owner accepts the ownership transfer.\n */\n function acceptOwnership() public virtual {\n address sender = _msgSender();\n require(pendingOwner() == sender, \"Ownable2Step: caller is not the new owner\");\n _transferOwnership(sender);\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n function __Ownable_init() internal onlyInitializing {\n __Ownable_init_unchained();\n }\n\n function __Ownable_init_unchained() internal onlyInitializing {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if the sender is not the owner.\n */\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby disabling any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n */\n uint8 private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint8 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts.\n *\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n * constructor.\n *\n * Emits an {Initialized} event.\n */\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n * are added through upgrades and that require initialization.\n *\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n * cannot be nested. If one is invoked in the context of another, execution will revert.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n *\n * WARNING: setting the version to 255 will prevent any future reinitialization.\n *\n * Emits an {Initialized} event.\n */\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n *\n * Emits an {Initialized} event the first time it is successfully executed.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized != type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n\n /**\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\n */\n function _getInitializedVersion() internal view returns (uint8) {\n return _initialized;\n }\n\n /**\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n */\n function _isInitializing() internal view returns (bool) {\n return _initializing;\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n /**\n * @dev Emitted when the pause is triggered by `account`.\n */\n event Paused(address account);\n\n /**\n * @dev Emitted when the pause is lifted by `account`.\n */\n event Unpaused(address account);\n\n bool private _paused;\n\n /**\n * @dev Initializes the contract in unpaused state.\n */\n function __Pausable_init() internal onlyInitializing {\n __Pausable_init_unchained();\n }\n\n function __Pausable_init_unchained() internal onlyInitializing {\n _paused = false;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is not paused.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n modifier whenNotPaused() {\n _requireNotPaused();\n _;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is paused.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n modifier whenPaused() {\n _requirePaused();\n _;\n }\n\n /**\n * @dev Returns true if the contract is paused, and false otherwise.\n */\n function paused() public view virtual returns (bool) {\n return _paused;\n }\n\n /**\n * @dev Throws if the contract is paused.\n */\n function _requireNotPaused() internal view virtual {\n require(!paused(), \"Pausable: paused\");\n }\n\n /**\n * @dev Throws if the contract is not paused.\n */\n function _requirePaused() internal view virtual {\n require(paused(), \"Pausable: not paused\");\n }\n\n /**\n * @dev Triggers stopped state.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n function _pause() internal virtual whenNotPaused {\n _paused = true;\n emit Paused(_msgSender());\n }\n\n /**\n * @dev Returns to normal state.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n function _unpause() internal virtual whenPaused {\n _paused = false;\n emit Unpaused(_msgSender());\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuardUpgradeable is Initializable {\n // Booleans are more expensive than uint256 or any type that takes up a full\n // word because each write operation emits an extra SLOAD to first read the\n // slot's contents, replace the bits taken up by the boolean, and then write\n // back. This is the compiler's defense against contract upgrades and\n // pointer aliasing, and it cannot be disabled.\n\n // The values being non-zero value makes deployment a bit more expensive,\n // but in exchange the refund on every call to nonReentrant will be lower in\n // amount. Since refunds are capped to a percentage of the total\n // transaction's gas, it is best to keep them low in cases like this one, to\n // increase the likelihood of the full refund coming into effect.\n uint256 private constant _NOT_ENTERED = 1;\n uint256 private constant _ENTERED = 2;\n\n uint256 private _status;\n\n function __ReentrancyGuard_init() internal onlyInitializing {\n __ReentrancyGuard_init_unchained();\n }\n\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\n _status = _NOT_ENTERED;\n }\n\n /**\n * @dev Prevents a contract from calling itself, directly or indirectly.\n * Calling a `nonReentrant` function from another `nonReentrant`\n * function is not supported. It is possible to prevent this from happening\n * by making the `nonReentrant` function external, and making it call a\n * `private` function that does the actual work.\n */\n modifier nonReentrant() {\n _nonReentrantBefore();\n _;\n _nonReentrantAfter();\n }\n\n function _nonReentrantBefore() private {\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\n require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n // Any calls to nonReentrant after this point will fail\n _status = _ENTERED;\n }\n\n function _nonReentrantAfter() private {\n // By storing the original value once again, a refund is triggered (see\n // https://eips.ethereum.org/EIPS/eip-2200)\n _status = _NOT_ENTERED;\n }\n\n /**\n * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n * `nonReentrant` function in the call stack.\n */\n function _reentrancyGuardEntered() internal view returns (bool) {\n return _status == _ENTERED;\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20PermitUpgradeable {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\nimport \"../extensions/IERC20PermitUpgradeable.sol\";\nimport \"../../../utils/AddressUpgradeable.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20Upgradeable {\n using AddressUpgradeable for address;\n\n /**\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n /**\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n */\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n require(\n (value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n /**\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n uint256 oldAllowance = token.allowance(address(this), spender);\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\n }\n\n /**\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\n }\n }\n\n /**\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n * to be set to zero before setting it to a non-zero value, such as USDT.\n */\n function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\n\n if (!_callOptionalReturnBool(token, approvalCall)) {\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\n _callOptionalReturn(token, approvalCall);\n }\n }\n\n /**\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\n * Revert on invalid signature.\n */\n function safePermit(\n IERC20PermitUpgradeable token,\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal {\n uint256 nonceBefore = token.nonces(owner);\n token.permit(owner, spender, value, deadline, v, r, s);\n uint256 nonceAfter = token.nonces(owner);\n require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n *\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n */\n function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n // and not revert is the subcall reverts.\n\n (bool success, bytes memory returndata) = address(token).call(data);\n return\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n *\n * Furthermore, `isContract` will also return true if the target contract within\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n * which only has an effect at the end of a transaction.\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n *\n * _Available since v4.8._\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n if (success) {\n if (returndata.length == 0) {\n // only check isContract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n require(isContract(target), \"Address: call to non-contract\");\n }\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason or using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n function __Context_init() internal onlyInitializing {\n }\n\n function __Context_init_unchained() internal onlyInitializing {\n }\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n" + }, + "@openzeppelin/contracts/access/IAccessControl.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {AccessControl-_setupRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) external view returns (bool);\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n */\n function renounceRole(bytes32 role, address account) external;\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/IERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n" + }, + "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\";\n\nimport \"./IAccessControlManagerV8.sol\";\n\n/**\n * @title AccessControlledV8\n * @author Venus\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.8.13)\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\n */\nabstract contract AccessControlledV8 is Initializable, Ownable2StepUpgradeable {\n /// @notice Access control manager contract\n IAccessControlManagerV8 private _accessControlManager;\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n\n /// @notice Emitted when access control manager contract address is changed\n event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\n\n /// @notice Thrown when the action is prohibited by AccessControlManager\n error Unauthorized(address sender, address calledContract, string methodSignature);\n\n function __AccessControlled_init(address accessControlManager_) internal onlyInitializing {\n __Ownable2Step_init();\n __AccessControlled_init_unchained(accessControlManager_);\n }\n\n function __AccessControlled_init_unchained(address accessControlManager_) internal onlyInitializing {\n _setAccessControlManager(accessControlManager_);\n }\n\n /**\n * @notice Sets the address of AccessControlManager\n * @dev Admin function to set address of AccessControlManager\n * @param accessControlManager_ The new address of the AccessControlManager\n * @custom:event Emits NewAccessControlManager event\n * @custom:access Only Governance\n */\n function setAccessControlManager(address accessControlManager_) external onlyOwner {\n _setAccessControlManager(accessControlManager_);\n }\n\n /**\n * @notice Returns the address of the access control manager contract\n */\n function accessControlManager() external view returns (IAccessControlManagerV8) {\n return _accessControlManager;\n }\n\n /**\n * @dev Internal function to set address of AccessControlManager\n * @param accessControlManager_ The new address of the AccessControlManager\n */\n function _setAccessControlManager(address accessControlManager_) internal {\n require(address(accessControlManager_) != address(0), \"invalid acess control manager address\");\n address oldAccessControlManager = address(_accessControlManager);\n _accessControlManager = IAccessControlManagerV8(accessControlManager_);\n emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\n }\n\n /**\n * @notice Reverts if the call is not allowed by AccessControlManager\n * @param signature Method signature\n */\n function _checkAccessAllowed(string memory signature) internal view {\n bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\n\n if (!isAllowedToCall) {\n revert Unauthorized(msg.sender, address(this), signature);\n }\n }\n}\n" + }, + "@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport \"@openzeppelin/contracts/access/IAccessControl.sol\";\n\n/**\n * @title IAccessControlManagerV8\n * @author Venus\n * @notice Interface implemented by the `AccessControlManagerV8` contract.\n */\ninterface IAccessControlManagerV8 is IAccessControl {\n function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\n\n function revokeCallPermission(\n address contractAddress,\n string calldata functionSig,\n address accountToRevoke\n ) external;\n\n function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\n\n function hasPermission(\n address account,\n address contractAddress,\n string calldata functionSig\n ) external view returns (bool);\n}\n" + }, + "@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\ninterface OracleInterface {\n function getPrice(address asset) external view returns (uint256);\n}\n\ninterface ResilientOracleInterface is OracleInterface {\n function updatePrice(address vToken) external;\n\n function updateAssetPrice(address asset) external;\n\n function getUnderlyingPrice(address vToken) external view returns (uint256);\n}\n\ninterface TwapInterface is OracleInterface {\n function updateTwap(address asset) external returns (uint256);\n}\n\ninterface BoundValidatorInterface {\n function validatePriceWithAnchorPrice(\n address asset,\n uint256 reporterPrice,\n uint256 anchorPrice\n ) external view returns (bool);\n}\n" + }, + "@venusprotocol/oracle/contracts/interfaces/VBep20Interface.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface VBep20Interface is IERC20Metadata {\n /**\n * @notice Underlying asset for this VToken\n */\n function underlying() external view returns (address);\n}\n" + }, + "@venusprotocol/oracle/contracts/ResilientOracle.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\n// SPDX-FileCopyrightText: 2022 Venus\npragma solidity 0.8.25;\n\nimport \"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\";\nimport \"./interfaces/VBep20Interface.sol\";\nimport \"./interfaces/OracleInterface.sol\";\nimport \"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\";\n\n/**\n * @title ResilientOracle\n * @author Venus\n * @notice The Resilient Oracle is the main contract that the protocol uses to fetch prices of assets.\n *\n * DeFi protocols are vulnerable to price oracle failures including oracle manipulation and incorrectly\n * reported prices. If only one oracle is used, this creates a single point of failure and opens a vector\n * for attacking the protocol.\n *\n * The Resilient Oracle uses multiple sources and fallback mechanisms to provide accurate prices and protect\n * the protocol from oracle attacks. Currently it includes integrations with Chainlink, Pyth, Binance Oracle\n * and TWAP (Time-Weighted Average Price) oracles. TWAP uses PancakeSwap as the on-chain price source.\n *\n * For every market (vToken) we configure the main, pivot and fallback oracles. The oracles are configured per\n * vToken's underlying asset address. The main oracle oracle is the most trustworthy price source, the pivot\n * oracle is used as a loose sanity checker and the fallback oracle is used as a backup price source.\n *\n * To validate prices returned from two oracles, we use an upper and lower bound ratio that is set for every\n * market. The upper bound ratio represents the deviation between reported price (the price that’s being\n * validated) and the anchor price (the price we are validating against) above which the reported price will\n * be invalidated. The lower bound ratio presents the deviation between reported price and anchor price below\n * which the reported price will be invalidated. So for oracle price to be considered valid the below statement\n * should be true:\n\n```\nanchorRatio = anchorPrice/reporterPrice\nisValid = anchorRatio <= upperBoundAnchorRatio && anchorRatio >= lowerBoundAnchorRatio\n```\n\n * In most cases, Chainlink is used as the main oracle, TWAP or Pyth oracles are used as the pivot oracle depending\n * on which supports the given market and Binance oracle is used as the fallback oracle. For some markets we may\n * use Pyth or TWAP as the main oracle if the token price is not supported by Chainlink or Binance oracles.\n *\n * For a fetched price to be valid it must be positive and not stagnant. If the price is invalid then we consider the\n * oracle to be stagnant and treat it like it's disabled.\n */\ncontract ResilientOracle is PausableUpgradeable, AccessControlledV8, ResilientOracleInterface {\n /**\n * @dev Oracle roles:\n * **main**: The most trustworthy price source\n * **pivot**: Price oracle used as a loose sanity checker\n * **fallback**: The backup source when main oracle price is invalidated\n */\n enum OracleRole {\n MAIN,\n PIVOT,\n FALLBACK\n }\n\n struct TokenConfig {\n /// @notice asset address\n address asset;\n /// @notice `oracles` stores the oracles based on their role in the following order:\n /// [main, pivot, fallback],\n /// It can be indexed with the corresponding enum OracleRole value\n address[3] oracles;\n /// @notice `enableFlagsForOracles` stores the enabled state\n /// for each oracle in the same order as `oracles`\n bool[3] enableFlagsForOracles;\n }\n\n uint256 public constant INVALID_PRICE = 0;\n\n /// @notice Native market address\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n address public immutable nativeMarket;\n\n /// @notice VAI address\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n address public immutable vai;\n\n /// @notice Set this as asset address for Native token on each chain.This is the underlying for vBNB (on bsc)\n /// and can serve as any underlying asset of a market that supports native tokens\n address public constant NATIVE_TOKEN_ADDR = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\n\n /// @notice Bound validator contract address\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n BoundValidatorInterface public immutable boundValidator;\n\n mapping(address => TokenConfig) private tokenConfigs;\n\n event TokenConfigAdded(\n address indexed asset,\n address indexed mainOracle,\n address indexed pivotOracle,\n address fallbackOracle\n );\n\n /// Event emitted when an oracle is set\n event OracleSet(address indexed asset, address indexed oracle, uint256 indexed role);\n\n /// Event emitted when an oracle is enabled or disabled\n event OracleEnabled(address indexed asset, uint256 indexed role, bool indexed enable);\n\n /**\n * @notice Checks whether an address is null or not\n */\n modifier notNullAddress(address someone) {\n if (someone == address(0)) revert(\"can't be zero address\");\n _;\n }\n\n /**\n * @notice Checks whether token config exists by checking whether asset is null address\n * @dev address can't be null, so it's suitable to be used to check the validity of the config\n * @param asset asset address\n */\n modifier checkTokenConfigExistence(address asset) {\n if (tokenConfigs[asset].asset == address(0)) revert(\"token config must exist\");\n _;\n }\n\n /// @notice Constructor for the implementation contract. Sets immutable variables.\n /// @dev nativeMarketAddress can be address(0) if on the chain we do not support native market\n /// (e.g vETH on ethereum would not be supported, only vWETH)\n /// @param nativeMarketAddress The address of a native market (for bsc it would be vBNB address)\n /// @param vaiAddress The address of the VAI token (if there is VAI on the deployed chain).\n /// Set to address(0) of VAI is not existent.\n /// @param _boundValidator Address of the bound validator contract\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor(\n address nativeMarketAddress,\n address vaiAddress,\n BoundValidatorInterface _boundValidator\n ) notNullAddress(address(_boundValidator)) {\n nativeMarket = nativeMarketAddress;\n vai = vaiAddress;\n boundValidator = _boundValidator;\n\n _disableInitializers();\n }\n\n /**\n * @notice Initializes the contract admin and sets the BoundValidator contract address\n * @param accessControlManager_ Address of the access control manager contract\n */\n function initialize(address accessControlManager_) external initializer {\n __AccessControlled_init(accessControlManager_);\n __Pausable_init();\n }\n\n /**\n * @notice Pauses oracle\n * @custom:access Only Governance\n */\n function pause() external {\n _checkAccessAllowed(\"pause()\");\n _pause();\n }\n\n /**\n * @notice Unpauses oracle\n * @custom:access Only Governance\n */\n function unpause() external {\n _checkAccessAllowed(\"unpause()\");\n _unpause();\n }\n\n /**\n * @notice Batch sets token configs\n * @param tokenConfigs_ Token config array\n * @custom:access Only Governance\n * @custom:error Throws a length error if the length of the token configs array is 0\n */\n function setTokenConfigs(TokenConfig[] memory tokenConfigs_) external {\n if (tokenConfigs_.length == 0) revert(\"length can't be 0\");\n uint256 numTokenConfigs = tokenConfigs_.length;\n for (uint256 i; i < numTokenConfigs; ) {\n setTokenConfig(tokenConfigs_[i]);\n unchecked {\n ++i;\n }\n }\n }\n\n /**\n * @notice Sets oracle for a given asset and role.\n * @dev Supplied asset **must** exist and main oracle may not be null\n * @param asset Asset address\n * @param oracle Oracle address\n * @param role Oracle role\n * @custom:access Only Governance\n * @custom:error Null address error if main-role oracle address is null\n * @custom:error NotNullAddress error is thrown if asset address is null\n * @custom:error TokenConfigExistance error is thrown if token config is not set\n * @custom:event Emits OracleSet event with asset address, oracle address and role of the oracle for the asset\n */\n function setOracle(\n address asset,\n address oracle,\n OracleRole role\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\n _checkAccessAllowed(\"setOracle(address,address,uint8)\");\n if (oracle == address(0) && role == OracleRole.MAIN) revert(\"can't set zero address to main oracle\");\n tokenConfigs[asset].oracles[uint256(role)] = oracle;\n emit OracleSet(asset, oracle, uint256(role));\n }\n\n /**\n * @notice Enables/ disables oracle for the input asset. Token config for the input asset **must** exist\n * @dev Configuration for the asset **must** already exist and the asset cannot be 0 address\n * @param asset Asset address\n * @param role Oracle role\n * @param enable Enabled boolean of the oracle\n * @custom:access Only Governance\n * @custom:error NotNullAddress error is thrown if asset address is null\n * @custom:error TokenConfigExistance error is thrown if token config is not set\n */\n function enableOracle(\n address asset,\n OracleRole role,\n bool enable\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\n _checkAccessAllowed(\"enableOracle(address,uint8,bool)\");\n tokenConfigs[asset].enableFlagsForOracles[uint256(role)] = enable;\n emit OracleEnabled(asset, uint256(role), enable);\n }\n\n /**\n * @notice Updates the TWAP pivot oracle price.\n * @dev This function should always be called before calling getUnderlyingPrice\n * @param vToken vToken address\n */\n function updatePrice(address vToken) external override {\n address asset = _getUnderlyingAsset(vToken);\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\n if (pivotOracle != address(0) && pivotOracleEnabled) {\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\n }\n }\n\n /**\n * @notice Updates the pivot oracle price. Currently using TWAP\n * @dev This function should always be called before calling getPrice\n * @param asset asset address\n */\n function updateAssetPrice(address asset) external {\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\n if (pivotOracle != address(0) && pivotOracleEnabled) {\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\n }\n }\n\n /**\n * @dev Gets token config by asset address\n * @param asset asset address\n * @return tokenConfig Config for the asset\n */\n function getTokenConfig(address asset) external view returns (TokenConfig memory) {\n return tokenConfigs[asset];\n }\n\n /**\n * @notice Gets price of the underlying asset for a given vToken. Validation flow:\n * - Check if the oracle is paused globally\n * - Validate price from main oracle against pivot oracle\n * - Validate price from fallback oracle against pivot oracle if the first validation failed\n * - Validate price from main oracle against fallback oracle if the second validation failed\n * In the case that the pivot oracle is not available but main price is available and validation is successful,\n * main oracle price is returned.\n * @param vToken vToken address\n * @return price USD price in scaled decimal places.\n * @custom:error Paused error is thrown when resilent oracle is paused\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\n */\n function getUnderlyingPrice(address vToken) external view override returns (uint256) {\n if (paused()) revert(\"resilient oracle is paused\");\n\n address asset = _getUnderlyingAsset(vToken);\n return _getPrice(asset);\n }\n\n /**\n * @notice Gets price of the asset\n * @param asset asset address\n * @return price USD price in scaled decimal places.\n * @custom:error Paused error is thrown when resilent oracle is paused\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\n */\n function getPrice(address asset) external view override returns (uint256) {\n if (paused()) revert(\"resilient oracle is paused\");\n return _getPrice(asset);\n }\n\n /**\n * @notice Sets/resets single token configs.\n * @dev main oracle **must not** be a null address\n * @param tokenConfig Token config struct\n * @custom:access Only Governance\n * @custom:error NotNullAddress is thrown if asset address is null\n * @custom:error NotNullAddress is thrown if main-role oracle address for asset is null\n * @custom:event Emits TokenConfigAdded event when the asset config is set successfully by the authorized account\n */\n function setTokenConfig(\n TokenConfig memory tokenConfig\n ) public notNullAddress(tokenConfig.asset) notNullAddress(tokenConfig.oracles[uint256(OracleRole.MAIN)]) {\n _checkAccessAllowed(\"setTokenConfig(TokenConfig)\");\n\n tokenConfigs[tokenConfig.asset] = tokenConfig;\n emit TokenConfigAdded(\n tokenConfig.asset,\n tokenConfig.oracles[uint256(OracleRole.MAIN)],\n tokenConfig.oracles[uint256(OracleRole.PIVOT)],\n tokenConfig.oracles[uint256(OracleRole.FALLBACK)]\n );\n }\n\n /**\n * @notice Gets oracle and enabled status by asset address\n * @param asset asset address\n * @param role Oracle role\n * @return oracle Oracle address based on role\n * @return enabled Enabled flag of the oracle based on token config\n */\n function getOracle(address asset, OracleRole role) public view returns (address oracle, bool enabled) {\n oracle = tokenConfigs[asset].oracles[uint256(role)];\n enabled = tokenConfigs[asset].enableFlagsForOracles[uint256(role)];\n }\n\n function _getPrice(address asset) internal view returns (uint256) {\n uint256 pivotPrice = INVALID_PRICE;\n\n // Get pivot oracle price, Invalid price if not available or error\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\n if (pivotOracleEnabled && pivotOracle != address(0)) {\n try OracleInterface(pivotOracle).getPrice(asset) returns (uint256 pricePivot) {\n pivotPrice = pricePivot;\n } catch {}\n }\n\n // Compare main price and pivot price, return main price and if validation was successful\n // note: In case pivot oracle is not available but main price is available and\n // validation is successful, the main oracle price is returned.\n (uint256 mainPrice, bool validatedPivotMain) = _getMainOraclePrice(\n asset,\n pivotPrice,\n pivotOracleEnabled && pivotOracle != address(0)\n );\n if (mainPrice != INVALID_PRICE && validatedPivotMain) return mainPrice;\n\n // Compare fallback and pivot if main oracle comparision fails with pivot\n // Return fallback price when fallback price is validated successfully with pivot oracle\n (uint256 fallbackPrice, bool validatedPivotFallback) = _getFallbackOraclePrice(asset, pivotPrice);\n if (fallbackPrice != INVALID_PRICE && validatedPivotFallback) return fallbackPrice;\n\n // Lastly compare main price and fallback price\n if (\n mainPrice != INVALID_PRICE &&\n fallbackPrice != INVALID_PRICE &&\n boundValidator.validatePriceWithAnchorPrice(asset, mainPrice, fallbackPrice)\n ) {\n return mainPrice;\n }\n\n revert(\"invalid resilient oracle price\");\n }\n\n /**\n * @notice Gets a price for the provided asset\n * @dev This function won't revert when price is 0, because the fallback oracle may still be\n * able to fetch a correct price\n * @param asset asset address\n * @param pivotPrice Pivot oracle price\n * @param pivotEnabled If pivot oracle is not empty and enabled\n * @return price USD price in scaled decimals\n * e.g. asset decimals is 8 then price is returned as 10**18 * 10**(18-8) = 10**28 decimals\n * @return pivotValidated Boolean representing if the validation of main oracle price\n * and pivot oracle price were successful\n * @custom:error Invalid price error is thrown if main oracle fails to fetch price of the asset\n * @custom:error Invalid price error is thrown if main oracle is not enabled or main oracle\n * address is null\n */\n function _getMainOraclePrice(\n address asset,\n uint256 pivotPrice,\n bool pivotEnabled\n ) internal view returns (uint256, bool) {\n (address mainOracle, bool mainOracleEnabled) = getOracle(asset, OracleRole.MAIN);\n if (mainOracleEnabled && mainOracle != address(0)) {\n try OracleInterface(mainOracle).getPrice(asset) returns (uint256 mainOraclePrice) {\n if (!pivotEnabled) {\n return (mainOraclePrice, true);\n }\n if (pivotPrice == INVALID_PRICE) {\n return (mainOraclePrice, false);\n }\n return (\n mainOraclePrice,\n boundValidator.validatePriceWithAnchorPrice(asset, mainOraclePrice, pivotPrice)\n );\n } catch {\n return (INVALID_PRICE, false);\n }\n }\n\n return (INVALID_PRICE, false);\n }\n\n /**\n * @dev This function won't revert when the price is 0 because getPrice checks if price is > 0\n * @param asset asset address\n * @return price USD price in 18 decimals\n * @return pivotValidated Boolean representing if the validation of fallback oracle price\n * and pivot oracle price were successfully\n * @custom:error Invalid price error is thrown if fallback oracle fails to fetch price of the asset\n * @custom:error Invalid price error is thrown if fallback oracle is not enabled or fallback oracle\n * address is null\n */\n function _getFallbackOraclePrice(address asset, uint256 pivotPrice) private view returns (uint256, bool) {\n (address fallbackOracle, bool fallbackEnabled) = getOracle(asset, OracleRole.FALLBACK);\n if (fallbackEnabled && fallbackOracle != address(0)) {\n try OracleInterface(fallbackOracle).getPrice(asset) returns (uint256 fallbackOraclePrice) {\n if (pivotPrice == INVALID_PRICE) {\n return (fallbackOraclePrice, false);\n }\n return (\n fallbackOraclePrice,\n boundValidator.validatePriceWithAnchorPrice(asset, fallbackOraclePrice, pivotPrice)\n );\n } catch {\n return (INVALID_PRICE, false);\n }\n }\n\n return (INVALID_PRICE, false);\n }\n\n /**\n * @dev This function returns the underlying asset of a vToken\n * @param vToken vToken address\n * @return asset underlying asset address\n */\n function _getUnderlyingAsset(address vToken) private view notNullAddress(vToken) returns (address asset) {\n if (vToken == nativeMarket) {\n asset = NATIVE_TOKEN_ADDR;\n } else if (vToken == vai) {\n asset = vai;\n } else {\n asset = VBep20Interface(vToken).underlying();\n }\n }\n}\n" + }, + "@venusprotocol/solidity-utilities/contracts/constants.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\n/// @dev Base unit for computations, usually used in scaling (multiplications, divisions)\nuint256 constant EXP_SCALE = 1e18;\n\n/// @dev A unit (literal one) in EXP_SCALE, usually used in additions/subtractions\nuint256 constant MANTISSA_ONE = EXP_SCALE;\n\n/// @dev The approximate number of seconds per year\nuint256 constant SECONDS_PER_YEAR = 31_536_000;\n" + }, + "@venusprotocol/solidity-utilities/contracts/validators.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\n/// @notice Thrown if the supplied address is a zero address where it is not allowed\nerror ZeroAddressNotAllowed();\n\n/// @notice Thrown if the supplied value is 0 where it is not allowed\nerror ZeroValueNotAllowed();\n\n/// @notice Checks if the provided address is nonzero, reverts otherwise\n/// @param address_ Address to check\n/// @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address\nfunction ensureNonzeroAddress(address address_) pure {\n if (address_ == address(0)) {\n revert ZeroAddressNotAllowed();\n }\n}\n\n/// @notice Checks if the provided value is nonzero, reverts otherwise\n/// @param value_ Value to check\n/// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\nfunction ensureNonzeroValue(uint256 value_) pure {\n if (value_ == 0) {\n revert ZeroValueNotAllowed();\n }\n}\n" + }, + "contracts/Interfaces/IConverterNetwork.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport { IAbstractTokenConverter } from \"../TokenConverter/IAbstractTokenConverter.sol\";\n\n/**\n * @title IConverterNetwork\n * @author Venus\n * @notice Interface implemented by `ConverterNetwork`.\n */\ninterface IConverterNetwork {\n /// @notice Adds new converter to the array\n /// @param _tokenConverter Address of the token converter\n function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;\n\n /// @notice Removes converter from the array\n /// @param _tokenConverter Address of the token converter\n function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;\n\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\n /// @param _tokenAddressIn Address of tokenIn\n /// @param _tokenAddressOut Address of tokenOut\n /// @return converters Array of the conveters on the basis of the tokens pair\n /// @return convertersBalance Array of balances with respect to token out\n function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)\n external\n returns (address[] memory converters, uint256[] memory convertersBalance);\n\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\n /// @param _tokenAddressIn Address of tokenIn\n /// @param _tokenAddressOut Address of tokenOut\n /// @return converters Array of the conveters on the basis of the tokens pair\n /// @return convertersBalance Array of balances with respect to token out\n function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)\n external\n returns (address[] memory converters, uint256[] memory convertersBalance);\n\n /// @notice This function returns the array containing all the converters addresses\n /// @return Array containing all the converters addresses\n function getAllConverters() external view returns (IAbstractTokenConverter[] memory);\n\n /// @notice This function checks for given address is converter or not\n /// @param _tokenConverter Address of the token converter\n /// @return boolean true if given address is converter otherwise false\n function isTokenConverter(address _tokenConverter) external view returns (bool);\n}\n" + }, + "contracts/TokenConverter/AbstractTokenConverter.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\nimport { ReentrancyGuardUpgradeable } from \"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\";\nimport { SafeERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\nimport { AccessControlledV8 } from \"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\";\nimport { IERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\";\nimport { ResilientOracle } from \"@venusprotocol/oracle/contracts/ResilientOracle.sol\";\nimport { ensureNonzeroAddress, ensureNonzeroValue } from \"@venusprotocol/solidity-utilities/contracts/validators.sol\";\nimport { MANTISSA_ONE, EXP_SCALE } from \"@venusprotocol/solidity-utilities/contracts/constants.sol\";\n\nimport { IAbstractTokenConverter } from \"./IAbstractTokenConverter.sol\";\nimport { IConverterNetwork } from \"../Interfaces/IConverterNetwork.sol\";\n\n/// @title AbstractTokenConverter\n/// @author Venus\n/// @notice Abstract contract will be extended by SingleTokenConverter and RiskFundConverter\n/*\n * This contract specifies four functions for converting tokens, each applicable under following circumstances:\n *\n * Case I: TokenIn -> deflationary token, TokenOut -> deflationary token\n * In this scenario, functions supporting fees can only be utilized to convert tokens which are:\n * a. convertExactTokensSupportingFeeOnTransferTokens\n * b. convertForExactTokensSupportingFeeOnTransferTokens\n *\n * Case II: TokenIn -> deflationary token, TokenOut -> non-deflationary token\n * In this scenario, functions supporting fee can only be utilized to convert tokens which are:\n * similar to Case I.\n *\n * Case III: TokenIn -> non-deflationary token, TokenOut -> deflationary token\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\n * a. convertExactTokens\n * b. convertForExactTokens\n * c. convertExactTokensSupportingFeeOnTransferTokens\n * d. convertForExactTokensSupportingFeeOnTransferTokens\n *\n * Case IV: TokenIn -> non-deflationary token, TokenOut -> non-deflationary token\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\n * similar to Case III.\n *\n * ------------------------------------------------------------------------------------------------------------------------------------\n * Example 1:-\n * tokenInAddress - 0xaaaa.....\n * tokenOutAddress - 0xbbbb.....\n * tokenInAmount - 100\n * tokenOutMinAmount - minimum amount desired by the user(let's say 70)\n * Here user can use `convertExactTokens` or `convertExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\n * then `convertExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertExactTokens` is used).\n * Now first tokenInAddress tokens will be transferred from the user to the contract, on the basis of amount\n * received(as tokenInAddress can be deflationary token) tokenAmountOut will be calculated and will be transferred\n * to the user and if amount sent is less than tokenOutMinAmount, tx will revert. If amount sent is satisfied(let's say\n * 80 or even 70) then at last the actual amount received and the amount that was supposed to be received by the contract will\n * be compared, if they differ then the whole tx will revert as user was supposed to use `convertExactTokensSupportingFeeOnTransferTokens`\n * function for tokenIn as deflationary token.\n *\n * Example 2:-\n * tokenInAddress - 0xaaaa.....\n * tokenOutAddress - 0xbbbb.....\n * tokenInMaxAmount - maximum amount user is willing to provide(let's say 100)\n * tokenOutAmount - 70\n * Here user can use `convertForExactTokens` or `convertForExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\n * then `convertForExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertForExactTokens` is used),\n * which on the basis of tokenOutAmount provided will calculate tokenInAmount based on the tokens prices and will transfer\n * tokens from the user to the contract, now the actual amount received(as tokenInAddress can be deflationary token) will be\n * compared with tokenInMaxAmount if it is greater, tx will revert. If In amount is satisfied(let's say 90 or even 100) then\n * new tokenOutAmount will be calculated, and tokenOutAddress tokens will be transferred to the user, but at last the\n * old tokenOutAmount and new tokenOutAmount will be compared and if they differ whole tx will revert, because user was\n * supposed to use `convertForExactTokensSupportingFeeOnTransferTokens` function for tokenIn as deflationary token.\n * ------------------------------------------------------------------------------------------------------------------------------------\n *\n * This contract also supports private conversion between the converters:\n * Private conversions:\n * Private conversions is designed in order to convert the maximum amount of tokens received from PSR(to any converter) between\n * existing converters to save incentive and lower the dependency of users for conversion. So Private Conversion will be executed\n * by converters on it's own whenever funds are received from PSR. No incentive will be offered during private conversion.\n *\n * It will execute on updateAssetsState() function call in Converter Contracts. After this function call, converter will first\n * check for the amount received. If base asset is received then it will be directly sent to the destination address and no private\n * conversion will happen otherwise converter will interact with ConverterNetwork contract to find other valid converters who are providing the conversion for:\n *\n * tokenAddressIn: As asset received by that converter on updateAssetsState() function call.\n * tokenAddressOut: As base asset of that converter.\n *\n * ConverterNetwork:\n * This contract will contain all the converters, and will provide valid converters which can perform the execution according to tokenAddressIn\n * and tokenAddressOut provided.\n *\n * findTokenConverters():\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for users).\n *\n * findTokenConvertersForConverters():\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for converters).\n */\n\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\nabstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenConverter, ReentrancyGuardUpgradeable {\n using SafeERC20Upgradeable for IERC20Upgradeable;\n\n /// @notice Maximum incentive could be\n uint256 public constant MAX_INCENTIVE = 0.5e18;\n\n /// @notice Min amount to convert for private conversions. Defined in USD, with 18 decimals\n uint256 public minAmountToConvert;\n\n /// @notice Venus price oracle contract\n ResilientOracle public priceOracle;\n\n /// @notice conversion configurations for the existing pairs\n /// @dev tokenAddressIn => tokenAddressOut => ConversionConfig\n mapping(address => mapping(address => ConversionConfig)) public conversionConfigurations;\n\n /// @notice Address that all incoming tokens are transferred to\n address public destinationAddress;\n\n /// @notice Boolean for if conversion is paused\n bool public conversionPaused;\n\n /// @notice Address of the converterNetwork contract\n IConverterNetwork public converterNetwork;\n\n /// @dev This empty reserved space is put in place to allow future versions to add new\n /// variables without shifting down storage in the inheritance chain.\n /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n uint256[45] private __gap;\n\n /// @notice Emitted when config is updated for tokens pair\n event ConversionConfigUpdated(\n address indexed tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 oldIncentive,\n uint256 newIncentive,\n ConversionAccessibility oldAccess,\n ConversionAccessibility newAccess\n );\n /// @notice Emitted when price oracle address is updated\n event PriceOracleUpdated(ResilientOracle indexed oldPriceOracle, ResilientOracle indexed priceOracle);\n\n /// @notice Emitted when destination address is updated\n event DestinationAddressUpdated(address indexed oldDestinationAddress, address indexed destinationAddress);\n\n /// @notice Emitted when converterNetwork address is updated\n event ConverterNetworkAddressUpdated(address indexed oldConverterNetwork, address indexed converterNetwork);\n\n /// @notice Emitted when exact amount of tokens are converted for tokens\n event ConvertedExactTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when tokens are converted for exact amount of tokens\n event ConvertedForExactTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\n event ConvertedExactTokensSupportingFeeOnTransferTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\n event ConvertedForExactTokensSupportingFeeOnTransferTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when conversion is paused\n event ConversionPaused(address indexed sender);\n\n /// @notice Emitted when conversion is unpaused\n event ConversionResumed(address indexed sender);\n\n /// @notice Event emitted when tokens are swept\n event SweepToken(address indexed token, address indexed to, uint256 amount);\n\n /// @notice Emitted when minimum amount to convert is updated\n event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);\n\n /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\n error AmountOutMismatched();\n\n /// @notice Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\n error AmountInMismatched();\n\n /// @notice Thrown when given input amount is zero\n error InsufficientInputAmount();\n\n /// @notice Thrown when given output amount is zero\n error InsufficientOutputAmount();\n\n /// @notice Thrown when conversion is disabled or config does not exist for given pair\n error ConversionConfigNotEnabled();\n\n /// @notice Thrown when conversion is enabled only for private conversions\n error ConversionEnabledOnlyForPrivateConversions();\n\n /// @notice Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n error InvalidToAddress();\n\n /// @notice Thrown when incentive is higher than the MAX_INCENTIVE\n error IncentiveTooHigh(uint256 incentive, uint256 maxIncentive);\n\n /// @notice Thrown when amountOut is lower than amountOutMin\n error AmountOutLowerThanMinRequired(uint256 amountOutMantissa, uint256 amountOutMinMantissa);\n\n /// @notice Thrown when amountIn is higher than amountInMax\n error AmountInHigherThanMax(uint256 amountInMantissa, uint256 amountInMaxMantissa);\n\n /// @notice Thrown when conversion is paused\n error ConversionTokensPaused();\n\n /// @notice Thrown when conversion is Active\n error ConversionTokensActive();\n\n /// @notice Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\n error InvalidTokenConfigAddresses();\n\n /// @notice Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\n error InsufficientPoolLiquidity();\n\n /// @notice When address of the ConverterNetwork is not set or Zero address\n error InvalidConverterNetwork();\n\n /// @notice Thrown when trying to set non zero incentive for private conversion\n error NonZeroIncentiveForPrivateConversion();\n\n /// @notice Thrown when using convertForExactTokens deflationary tokens\n error DeflationaryTokenNotSupported();\n\n /// @notice Thrown when minimum amount to convert is zero\n error InvalidMinimumAmountToConvert();\n\n /// @notice Thrown when there is a mismatch in the length of input arrays\n error InputLengthMisMatch();\n\n /**\n * @notice Modifier to ensure valid conversion parameters for a token conversion\n * and check if conversion is paused or not\n * @param to The recipient address for the converted tokens\n * @param tokenAddressIn The input token address for the conversion\n * @param tokenAddressOut The output token address for the conversion\n */\n modifier validConversionParameters(\n address to,\n address tokenAddressIn,\n address tokenAddressOut\n ) {\n _checkConversionPaused();\n ensureNonzeroAddress(to);\n if (to == tokenAddressIn || to == tokenAddressOut) {\n revert InvalidToAddress();\n }\n _;\n }\n\n /// @notice Pause conversion of tokens\n /// @custom:event Emits ConversionPaused on success\n /// @custom:error ConversionTokensPaused thrown when conversion is already paused\n /// @custom:access Restricted by ACM\n function pauseConversion() external {\n _checkAccessAllowed(\"pauseConversion()\");\n _checkConversionPaused();\n conversionPaused = true;\n emit ConversionPaused(msg.sender);\n }\n\n /// @notice Resume conversion of tokens.\n /// @custom:event Emits ConversionResumed on success\n /// @custom:error ConversionTokensActive thrown when conversion is already active\n /// @custom:access Restricted by ACM\n function resumeConversion() external {\n _checkAccessAllowed(\"resumeConversion()\");\n if (!conversionPaused) {\n revert ConversionTokensActive();\n }\n\n conversionPaused = false;\n emit ConversionResumed(msg.sender);\n }\n\n /// @notice Sets a new price oracle\n /// @param priceOracle_ Address of the new price oracle to set\n /// @custom:access Only Governance\n function setPriceOracle(ResilientOracle priceOracle_) external onlyOwner {\n _setPriceOracle(priceOracle_);\n }\n\n /// @notice Sets a new destination address\n /// @param destinationAddress_ The new destination address to be set\n /// @custom:access Only Governance\n function setDestination(address destinationAddress_) external onlyOwner {\n _setDestination(destinationAddress_);\n }\n\n /// @notice Sets a converter network contract address\n /// @param converterNetwork_ The converterNetwork address to be set\n /// @custom:access Only Governance\n function setConverterNetwork(IConverterNetwork converterNetwork_) external onlyOwner {\n _setConverterNetwork(converterNetwork_);\n }\n\n /// @notice Min amount to convert setter\n /// @param minAmountToConvert_ Min amount to convert\n /// @custom:access Only Governance\n function setMinAmountToConvert(uint256 minAmountToConvert_) external {\n _checkAccessAllowed(\"setMinAmountToConvert(uint256)\");\n _setMinAmountToConvert(minAmountToConvert_);\n }\n\n /// @notice Batch sets the conversion configurations\n /// @param tokenAddressIn Address of tokenIn\n /// @param tokenAddressesOut Array of addresses of tokenOut\n /// @param conversionConfigs Array of conversionConfig config details to update\n /// @custom:error InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\n function setConversionConfigs(\n address tokenAddressIn,\n address[] calldata tokenAddressesOut,\n ConversionConfig[] calldata conversionConfigs\n ) external {\n uint256 tokenOutArrayLength = tokenAddressesOut.length;\n if (tokenOutArrayLength != conversionConfigs.length) revert InputLengthMisMatch();\n\n for (uint256 i; i < tokenOutArrayLength; ) {\n setConversionConfig(tokenAddressIn, tokenAddressesOut[i], conversionConfigs[i]);\n unchecked {\n ++i;\n }\n }\n }\n\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedExactTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n /// @custom:error AmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n function convertExactTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\n amountInMantissa,\n amountOutMinMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n if (actualAmountIn != amountInMantissa) {\n revert AmountInMismatched();\n }\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n }\n\n /// @notice Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract,\n /// otherwise the amount is adjusted\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedForExactTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n /// @custom:error AmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\n function convertForExactTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertForExactTokens(\n amountInMaxMantissa,\n amountOutMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n if (actualAmountOut != amountOutMantissa) {\n revert AmountOutMismatched();\n }\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedForExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n }\n\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n function convertExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\n amountInMantissa,\n amountOutMinMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedExactTokensSupportingFeeOnTransferTokens(\n msg.sender,\n to,\n tokenAddressIn,\n tokenAddressOut,\n actualAmountIn,\n actualAmountOut\n );\n }\n\n /// @notice Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of\n /// tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted.\n /// The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n function convertForExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertForExactTokensSupportingFeeOnTransferTokens(\n amountInMaxMantissa,\n amountOutMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedForExactTokensSupportingFeeOnTransferTokens(\n msg.sender,\n to,\n tokenAddressIn,\n tokenAddressOut,\n actualAmountIn,\n actualAmountOut\n );\n }\n\n /// @notice To sweep ERC20 tokens and transfer them to user(to address)\n /// @param tokenAddress The address of the ERC-20 token to sweep\n /// @param to The address to which tokens will be transferred\n /// @param amount The amount to transfer\n /// @custom:event Emits SweepToken event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\n /// @custom:access Only Governance\n function sweepToken(\n address tokenAddress,\n address to,\n uint256 amount\n ) external onlyOwner nonReentrant {\n ensureNonzeroAddress(tokenAddress);\n ensureNonzeroAddress(to);\n ensureNonzeroValue(amount);\n\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\n preSweepToken(tokenAddress, amount);\n token.safeTransfer(to, amount);\n\n emit SweepToken(tokenAddress, to, amount);\n }\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn.\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\n /// @notice The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\n /// @dev This function retrieves values without altering token prices\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\n function getAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\n if (\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\n ConversionAccessibility.ONLY_FOR_CONVERTERS\n ) {\n revert ConversionEnabledOnlyForPrivateConversions();\n }\n\n amountConvertedMantissa = amountInMantissa;\n uint256 tokenInToOutConversion;\n (amountOutMantissa, tokenInToOutConversion) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\n\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\n\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\n if (maxTokenOutReserve < amountOutMantissa) {\n amountConvertedMantissa = _divRoundingUp(maxTokenOutReserve * EXP_SCALE, tokenInToOutConversion);\n amountOutMantissa = maxTokenOutReserve;\n }\n }\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut.\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\n /// @dev This function retrieves values without altering token prices\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\n function getAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\n if (\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\n ConversionAccessibility.ONLY_FOR_CONVERTERS\n ) {\n revert ConversionEnabledOnlyForPrivateConversions();\n }\n\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\n\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\n if (maxTokenOutReserve < amountOutMantissa) {\n amountOutMantissa = maxTokenOutReserve;\n }\n\n amountConvertedMantissa = amountOutMantissa;\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n }\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) public returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\n priceOracle.updateAssetPrice(tokenAddressIn);\n priceOracle.updateAssetPrice(tokenAddressOut);\n\n (amountOutMantissa, ) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\n amountConvertedMantissa = amountInMantissa;\n }\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) public returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\n priceOracle.updateAssetPrice(tokenAddressIn);\n priceOracle.updateAssetPrice(tokenAddressOut);\n\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n amountConvertedMantissa = amountOutMantissa;\n }\n\n /// @notice This method updated the states of this contract after getting funds from PSR\n /// after settling the amount(if any) through privateConversion between converters\n /// @dev This function is called by protocolShareReserve\n /// @dev call _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then\n /// it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\n /// @param comptroller Comptroller address (pool)\n /// @param asset Asset address\n function updateAssetsState(address comptroller, address asset) public nonReentrant {\n uint256 balanceDiff = _updateAssetsState(comptroller, asset);\n if (balanceDiff > 0) {\n _privateConversion(comptroller, asset, balanceDiff);\n }\n }\n\n /// @notice Set the configuration for new or existing conversion pair\n /// @param tokenAddressIn Address of tokenIn\n /// @param tokenAddressOut Address of tokenOut\n /// @param conversionConfig ConversionConfig config details to update\n /// @custom:event Emits ConversionConfigUpdated event on success\n /// @custom:error Unauthorized error is thrown when the call is not authorized by AccessControlManager\n /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero\n /// @custom:error NonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\n /// @custom:access Controlled by AccessControlManager\n function setConversionConfig(\n address tokenAddressIn,\n address tokenAddressOut,\n ConversionConfig calldata conversionConfig\n ) public {\n _checkAccessAllowed(\"setConversionConfig(address,address,ConversionConfig)\");\n ensureNonzeroAddress(tokenAddressIn);\n ensureNonzeroAddress(tokenAddressOut);\n\n if (conversionConfig.incentive > MAX_INCENTIVE) {\n revert IncentiveTooHigh(conversionConfig.incentive, MAX_INCENTIVE);\n }\n\n if (\n (tokenAddressIn == tokenAddressOut) ||\n (tokenAddressIn != _getDestinationBaseAsset()) ||\n conversionConfigurations[tokenAddressOut][tokenAddressIn].conversionAccess != ConversionAccessibility.NONE\n ) {\n revert InvalidTokenConfigAddresses();\n }\n\n if (\n (conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) &&\n conversionConfig.incentive != 0\n ) {\n revert NonZeroIncentiveForPrivateConversion();\n }\n\n if (\n ((conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) ||\n (conversionConfig.conversionAccess == ConversionAccessibility.ALL)) &&\n (address(converterNetwork) == address(0))\n ) {\n revert InvalidConverterNetwork();\n }\n\n ConversionConfig storage configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\n\n emit ConversionConfigUpdated(\n tokenAddressIn,\n tokenAddressOut,\n configuration.incentive,\n conversionConfig.incentive,\n configuration.conversionAccess,\n conversionConfig.conversionAccess\n );\n\n if (conversionConfig.conversionAccess == ConversionAccessibility.NONE) {\n delete conversionConfigurations[tokenAddressIn][tokenAddressOut];\n } else {\n configuration.incentive = conversionConfig.incentive;\n configuration.conversionAccess = conversionConfig.conversionAccess;\n }\n }\n\n /// @notice Get the balance for specific token\n /// @param token Address of the token\n /// @return tokenBalance Balance of the token the contract has\n function balanceOf(address token) public view virtual returns (uint256 tokenBalance);\n\n /// @dev Operations to perform before sweeping tokens\n /// @param token Address of the token\n /// @param amount Amount transferred to address(to)\n function preSweepToken(address token, uint256 amount) internal virtual {}\n\n /// @dev Converts exact amount of tokenAddressIn for tokenAddressOut\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\n /// @return amountOutMantissa Actual amount of tokenAddressOut transferred\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n function _convertExactTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) internal returns (uint256 actualAmountIn, uint256 amountOutMantissa) {\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\n\n (, amountOutMantissa) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\n\n if (amountOutMantissa < amountOutMinMantissa) {\n revert AmountOutLowerThanMinRequired(amountOutMantissa, amountOutMinMantissa);\n }\n\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\n }\n\n /// @dev Converts tokens for tokenAddressIn for exact amount of tokenAddressOut used for non deflationry tokens\n /// it is called by convertForExactTokens function\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\n /// @custom:error DeflationaryTokenNotSupported is thrown if tokenAddressIn is deflationary token\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n function _convertForExactTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\n\n if (actualAmountIn != amountInMantissa) {\n revert DeflationaryTokenNotSupported();\n }\n\n if (actualAmountIn > amountInMaxMantissa) {\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\n }\n\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\n actualAmountOut = amountOutMantissa;\n }\n\n /// @dev Converts tokens for tokenAddressIn for the amount of tokenAddressOut used for deflationary tokens\n /// it is called by convertForExactTokensSupportingFeeOnTransferTokens function\n /// @notice Advising users to input a smaller amountOutMantissa to avoid potential transaction revert\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n function _convertForExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n\n if (amountInMantissa > amountInMaxMantissa) {\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\n }\n\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\n\n (, actualAmountOut) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\n\n _doTransferOut(tokenAddressOut, to, actualAmountOut);\n }\n\n /// @dev return actualAmountOut from reserves for tokenAddressOut\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred\n /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa\n function _doTransferOut(\n address tokenAddressOut,\n address to,\n uint256 amountConvertedMantissa\n ) internal {\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\n\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\n if (maxTokenOutReserve < amountConvertedMantissa) {\n revert InsufficientPoolLiquidity();\n }\n\n _preTransferHook(tokenAddressOut, amountConvertedMantissa);\n\n IERC20Upgradeable tokenOut = IERC20Upgradeable(tokenAddressOut);\n tokenOut.safeTransfer(to, amountConvertedMantissa);\n }\n\n /// @notice Transfer tokenAddressIn from user to destination\n /// @param tokenAddressIn Address of the token to convert\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @return actualAmountIn Actual amount transferred to destination\n function _doTransferIn(address tokenAddressIn, uint256 amountInMantissa) internal returns (uint256 actualAmountIn) {\n IERC20Upgradeable tokenIn = IERC20Upgradeable(tokenAddressIn);\n uint256 balanceBeforeDestination = tokenIn.balanceOf(destinationAddress);\n tokenIn.safeTransferFrom(msg.sender, destinationAddress, amountInMantissa);\n uint256 balanceAfterDestination = tokenIn.balanceOf(destinationAddress);\n actualAmountIn = balanceAfterDestination - balanceBeforeDestination;\n }\n\n /// @dev Sets a new price oracle\n /// @param priceOracle_ Address of the new price oracle to set\n /// @custom:event Emits PriceOracleUpdated event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero\n function _setPriceOracle(ResilientOracle priceOracle_) internal {\n ensureNonzeroAddress(address(priceOracle_));\n emit PriceOracleUpdated(priceOracle, priceOracle_);\n priceOracle = priceOracle_;\n }\n\n /// @dev Sets a new destination address\n /// @param destinationAddress_ The new destination address to be set\n /// @custom:event Emits DestinationAddressUpdated event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when destination address is zero\n function _setDestination(address destinationAddress_) internal {\n ensureNonzeroAddress(destinationAddress_);\n emit DestinationAddressUpdated(destinationAddress, destinationAddress_);\n destinationAddress = destinationAddress_;\n }\n\n /// @notice Sets a converter network contract address\n /// @param converterNetwork_ The converterNetwork address to be set\n /// @custom:event Emits ConverterNetworkAddressUpdated event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\n function _setConverterNetwork(IConverterNetwork converterNetwork_) internal {\n ensureNonzeroAddress(address(converterNetwork_));\n emit ConverterNetworkAddressUpdated(address(converterNetwork), address(converterNetwork_));\n converterNetwork = converterNetwork_;\n }\n\n /// @notice Min amount to convert setter\n /// @param minAmountToConvert_ Min amount to convert\n /// @custom:event MinAmountToConvertUpdated is emitted in success\n /// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\n function _setMinAmountToConvert(uint256 minAmountToConvert_) internal {\n ensureNonzeroValue(minAmountToConvert_);\n emit MinAmountToConvertUpdated(minAmountToConvert, minAmountToConvert_);\n minAmountToConvert = minAmountToConvert_;\n }\n\n /// @dev Hook to perform after converting tokens\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param amountIn Amount of tokenIn converted\n /// @param amountOut Amount of tokenOut converted\n function _postConversionHook(\n address tokenAddressIn,\n address tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n ) internal virtual {}\n\n /// @param accessControlManager_ Access control manager contract address\n /// @param priceOracle_ Resilient oracle address\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\n /// @param minAmountToConvert_ minimum amount to convert\n function __AbstractTokenConverter_init(\n address accessControlManager_,\n ResilientOracle priceOracle_,\n address destinationAddress_,\n uint256 minAmountToConvert_\n ) internal onlyInitializing {\n __AccessControlled_init(accessControlManager_);\n __ReentrancyGuard_init();\n __AbstractTokenConverter_init_unchained(priceOracle_, destinationAddress_, minAmountToConvert_);\n }\n\n /// @param priceOracle_ Resilient oracle address\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\n /// @param minAmountToConvert_ minimum amount to convert\n function __AbstractTokenConverter_init_unchained(\n ResilientOracle priceOracle_,\n address destinationAddress_,\n uint256 minAmountToConvert_\n ) internal onlyInitializing {\n _setPriceOracle(priceOracle_);\n _setDestination(destinationAddress_);\n _setMinAmountToConvert(minAmountToConvert_);\n conversionPaused = false;\n }\n\n /// @dev _updateAssetsState hook to update the states of reserves transferred for the specific comptroller\n /// @param comptroller Comptroller address (pool)\n /// @param asset Asset address\n /// @return Amount of asset, for _privateConversion\n function _updateAssetsState(address comptroller, address asset) internal virtual returns (uint256) {}\n\n /// @dev This method is used to convert asset into base asset by converting them with other converters which supports the pair and transfer the funds to\n /// destination contract as destination's base asset\n /// @param comptroller Comptroller address (pool)\n /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset\n /// @param amountToConvert Amount of the tokenAddressOut transferred to converter\n function _privateConversion(\n address comptroller,\n address tokenAddressOut,\n uint256 amountToConvert\n ) internal {\n address tokenAddressIn = _getDestinationBaseAsset();\n address _destinationAddress = destinationAddress;\n uint256 convertedTokenInBalance;\n if (address(converterNetwork) != address(0)) {\n (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork\n .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn);\n uint256 convertersLength = converterAddresses.length;\n for (uint256 i; i < convertersLength; ) {\n if (converterBalances[i] == 0) break;\n (, uint256 amountIn) = IAbstractTokenConverter(converterAddresses[i]).getUpdatedAmountIn(\n converterBalances[i],\n tokenAddressOut,\n tokenAddressIn\n );\n if (amountIn > amountToConvert) {\n amountIn = amountToConvert;\n }\n\n if (!_validateMinAmountToConvert(amountIn, tokenAddressOut)) {\n break;\n }\n\n uint256 balanceBefore = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\n\n IERC20Upgradeable(tokenAddressOut).forceApprove(converterAddresses[i], amountIn);\n IAbstractTokenConverter(converterAddresses[i]).convertExactTokens(\n amountIn,\n 0,\n tokenAddressOut,\n tokenAddressIn,\n _destinationAddress\n );\n\n uint256 balanceAfter = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\n amountToConvert -= amountIn;\n convertedTokenInBalance += (balanceAfter - balanceBefore);\n\n if (amountToConvert == 0) break;\n unchecked {\n ++i;\n }\n }\n }\n\n _postPrivateConversionHook(\n comptroller,\n tokenAddressIn,\n convertedTokenInBalance,\n tokenAddressOut,\n amountToConvert\n );\n }\n\n /// @dev This hook is used to update states for the converter after the privateConversion\n /// @param comptroller Comptroller address (pool)\n /// @param tokenAddressIn Address of the destination's base asset\n /// @param convertedTokenInBalance Amount of the base asset received after the conversion\n /// @param tokenAddressOut Address of the asset transferred to other converter in exchange of base asset\n /// @param convertedTokenOutBalance Amount of tokenAddressOut transferred from this converter\n function _postPrivateConversionHook(\n address comptroller,\n address tokenAddressIn,\n uint256 convertedTokenInBalance,\n address tokenAddressOut,\n uint256 convertedTokenOutBalance\n ) internal virtual {}\n\n /// @notice This hook is used to update the state for asset reserves before transferring tokenOut to user\n /// @param tokenOutAddress Address of the asset to be transferred to the user\n /// @param amountOut Amount of tokenAddressOut transferred from this converter\n function _preTransferHook(address tokenOutAddress, uint256 amountOut) internal virtual {}\n\n /// @dev Checks if amount to convert is greater than minimum amount to convert or not\n /// @param amountIn The amount to convert\n /// @param tokenAddress Address of the token\n /// @return isValid true if amount to convert is greater than minimum amount to convert\n function _validateMinAmountToConvert(uint256 amountIn, address tokenAddress) internal returns (bool isValid) {\n priceOracle.updateAssetPrice(tokenAddress);\n uint256 amountInInUsd = (priceOracle.getPrice(tokenAddress) * amountIn) / EXP_SCALE;\n\n if (amountInInUsd >= minAmountToConvert) {\n isValid = true;\n }\n }\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @dev This function retrieves values without altering token prices.\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function _getAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) internal view returns (uint256 amountOutMantissa, uint256 tokenInToOutConversion) {\n if (amountInMantissa == 0) {\n revert InsufficientInputAmount();\n }\n\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\n\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\n revert ConversionConfigNotEnabled();\n }\n\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\n\n uint256 incentive = configuration.incentive;\n if (address(converterNetwork) != address(0) && (converterNetwork.isTokenConverter(msg.sender))) {\n incentive = 0;\n }\n\n /// conversion rate after considering incentive(conversionWithIncentive)\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\n\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\n /// amount of tokenAddressOut after including incentive as amountOutMantissa will be greater than actual as it gets\n /// multiplied by conversionWithIncentive which will be >= 1\n amountOutMantissa = (amountInMantissa * tokenInToOutConversion) / (EXP_SCALE);\n }\n\n /// @dev To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @dev This function retrieves values without altering token prices.\n /// @dev For user conversions, the function returns an amountInMantissa that is rounded up, ensuring that the equivalent amountInMantissa\n /// is obtained from users for corresponding amountOutMantissa, preventing any losses to the protocol. However, no rounding up is required for private conversions\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function _getAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) internal view returns (uint256 amountInMantissa, uint256 tokenInToOutConversion) {\n if (amountOutMantissa == 0) {\n revert InsufficientOutputAmount();\n }\n\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\n\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\n revert ConversionConfigNotEnabled();\n }\n\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\n\n uint256 incentive = configuration.incentive;\n\n bool isPrivateConversion = address(converterNetwork) != address(0) &&\n converterNetwork.isTokenConverter(msg.sender);\n if (isPrivateConversion) {\n incentive = 0;\n }\n\n /// conversion rate after considering incentive(conversionWithIncentive)\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\n\n /// amount of tokenAddressIn after considering incentive(i.e. amountInMantissa will be less than actual amountInMantissa if incentive > 0)\n if (isPrivateConversion) {\n amountInMantissa =\n (amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE) /\n (tokenInUnderlyingPrice * conversionWithIncentive);\n } else {\n amountInMantissa = _divRoundingUp(\n amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE,\n tokenInUnderlyingPrice * conversionWithIncentive\n );\n }\n\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\n }\n\n /// @dev Check if msg.sender is allowed to convert as per onlyForPrivateConversions flag\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\n function _checkPrivateConversion(address tokenAddressIn, address tokenAddressOut) internal view {\n bool isConverter = (address(converterNetwork) != address(0)) && converterNetwork.isTokenConverter(msg.sender);\n if (\n (!(isConverter) &&\n (conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\n ConversionAccessibility.ONLY_FOR_CONVERTERS))\n ) {\n revert ConversionEnabledOnlyForPrivateConversions();\n }\n }\n\n /// @dev To check, is conversion paused\n /// @custom:error ConversionTokensPaused is thrown when token conversion is paused\n function _checkConversionPaused() internal view {\n if (conversionPaused) {\n revert ConversionTokensPaused();\n }\n }\n\n /// @dev Get base asset address of the destination contract\n /// @return Address of the base asset\n function _getDestinationBaseAsset() internal view virtual returns (address) {}\n\n /// @dev Performs division where the result is rounded up\n /// @param numerator The numerator of the division operation\n /// @param denominator The denominator of the division operation. Must be non-zero\n /// @return The result of the division, rounded up\n function _divRoundingUp(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\n return (numerator + denominator - 1) / denominator;\n }\n}\n" + }, + "contracts/TokenConverter/IAbstractTokenConverter.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport { ResilientOracle } from \"@venusprotocol/oracle/contracts/ResilientOracle.sol\";\nimport { IConverterNetwork } from \"../Interfaces/IConverterNetwork.sol\";\n\n/// @notice Interface for AbstractTokenConverter\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\ninterface IAbstractTokenConverter {\n /// @notice This enum define the all possible ways of conversion can happen\n enum ConversionAccessibility {\n NONE, // Conversion is disable for the pair\n ALL, // Conversion is enable for private conversion and users\n ONLY_FOR_CONVERTERS, // Conversion is enable only for private conversion\n ONLY_FOR_USERS // Conversion is enable only for users\n }\n\n /// @notice This struct represents the configuration for a token conversion.\n struct ConversionConfig {\n /// incentive on conversion of tokens in mantissa i.e 10% incentive would be 0.1 * 1e18\n uint256 incentive;\n /// enable or disable conversion for users or converters or both or none\n ConversionAccessibility conversionAccess;\n }\n\n /// @notice Pause conversion of tokens\n function pauseConversion() external;\n\n /// @notice Resume conversion of tokens.\n function resumeConversion() external;\n\n /// @notice Sets a new price oracle\n /// @param priceOracle_ Address of the new price oracle to set\n function setPriceOracle(ResilientOracle priceOracle_) external;\n\n /// @notice Set the configuration for new or existing convert pair\n /// @param tokenAddressIn Address of tokenIn\n /// @param tokenAddressOut Address of tokenOut\n /// @param conversionConfig ConversionConfig config details to update\n function setConversionConfig(\n address tokenAddressIn,\n address tokenAddressOut,\n ConversionConfig calldata conversionConfig\n ) external;\n\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertExactTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertForExactTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertForExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Get the configuration for the pair of the tokens\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return incentives Percentage of incentives to be distributed for the pair of tokens\n /// @return conversionAccess Accessibility for the pair of tokens\n function conversionConfigurations(address tokenAddressIn, address tokenAddressOut)\n external\n returns (uint256 incentives, ConversionAccessibility conversionAccess);\n\n /// @notice Get the address of the converterNetwork\n function converterNetwork() external returns (IConverterNetwork converterNetwork);\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @dev This function retrieves values without altering token prices.\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @dev This function retrieves values without altering token prices.\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\n\n /// @notice Get the balance for specific token\n /// @param token Address of the token\n /// @return tokenBalance Balance of the token the contract has\n function balanceOf(address token) external view returns (uint256 tokenBalance);\n}\n" + }, + "contracts/TokenConverter/SingleTokenConverter.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\nimport { SafeERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\nimport { IERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\";\nimport { ResilientOracle } from \"@venusprotocol/oracle/contracts/ResilientOracle.sol\";\nimport { ensureNonzeroAddress } from \"@venusprotocol/solidity-utilities/contracts/validators.sol\";\n\nimport { AbstractTokenConverter } from \"./AbstractTokenConverter.sol\";\n\n/// @title SingleTokenConverter\n/// @author Venus\n/// @notice SingleTokenConverter used for token conversions and sends received tokens\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\ncontract SingleTokenConverter is AbstractTokenConverter {\n using SafeERC20Upgradeable for IERC20Upgradeable;\n\n /// @notice Address of the base asset token\n address public baseAsset;\n\n /// @notice The mapping contains the assets which are sent to destination directly\n /// @dev Asset -> bool(should transfer directly on true)\n mapping(address => bool) public assetsDirectTransfer;\n\n /// @notice Emitted when base asset is updated\n event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset);\n\n /// @notice Emmitted after the funds transferred to the destination address\n event AssetTransferredToDestination(\n address indexed receiver,\n address indexed comptroller,\n address indexed asset,\n uint256 amount\n );\n\n /// @notice Emitted after the assetsDirectTransfer mapping is updated\n event AssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value);\n\n /// @notice Thrown when the base asset is the same as the new base asset\n error SameBaseAssetNotAllowed();\n\n /// @notice Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection\n error DirectTransferBaseAssetNotAllowed();\n\n /// @notice Thrown when the `assetsDirectTransfer[asset]` is already `value`\n /// @param asset The asset address whose `assetDirectTransfer` value went to be set\n /// @param value The value to be set\n error SameAssetDirectTransferNotAllowed(address asset, bool value);\n\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor() {\n // Note that the contract is upgradeable. Use initialize() or reinitializers\n // to set the state variables.\n _disableInitializers();\n }\n\n /// @param accessControlManager_ Access control manager contract address\n /// @param priceOracle_ Resilient oracle address\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\n /// @param baseAsset_ Address of the base asset\n /// @param minAmountToConvert_ Minimum amount to convert\n function initialize(\n address accessControlManager_,\n ResilientOracle priceOracle_,\n address destinationAddress_,\n address baseAsset_,\n uint256 minAmountToConvert_\n ) public initializer {\n _setBaseAsset(baseAsset_);\n\n // Initialize AbstractTokenConverter\n __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);\n }\n\n /// @notice Sets the base asset for the contract\n /// @param baseAsset_ The new address of the base asset\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\n /// @custom:event BaseAssetUpdated is emitted on success\n /// @custom:access Only Governance\n function setBaseAsset(address baseAsset_) external onlyOwner {\n _setBaseAsset(baseAsset_);\n }\n\n /// @notice Update the assetsDirectTransfer mapping\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\n /// @custom:event AssetsDirectTransferUpdated emits on success\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\n /// @custom:access Restricted by ACM\n function setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) external virtual {\n _checkAccessAllowed(\"setAssetsDirectTransfer(address[],bool[])\");\n _setAssetsDirectTransfer(assets, values);\n }\n\n /// @notice Get the balance for specific token\n /// @param tokenAddress Address of the token\n /// @return tokenBalance Balance of the token the contract has\n function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\n tokenBalance = token.balanceOf(address(this));\n }\n\n /// @dev It returns the balance of the `asset` in this contract. If `asset` is the `baseAsset`\n /// or `assetsDirectTransfer[asset]` is true, then the balance of `asset` in this contract will\n /// be transferred to the `destinationAddress` and 0 will be returned\n /// @param comptroller Comptroller address (pool)\n /// @param asset Asset address.\n /// @return balanceLeft Amount of asset, for _privateConversion\n function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) {\n IERC20Upgradeable token = IERC20Upgradeable(asset);\n uint256 balance = token.balanceOf(address(this));\n balanceLeft = balance;\n\n if (asset == baseAsset || assetsDirectTransfer[asset]) {\n balanceLeft = 0;\n token.safeTransfer(destinationAddress, balance);\n emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance);\n }\n }\n\n /// @notice Hook called after a private conversion is completed\n /// @dev Emits an AssetTransferredToDestination event if Private Conversion happens\n /// @param comptroller The address of the comptroller (pool) associated with the conversion\n /// @param tokenAddressIn The address of the input token that was converted\n /// @param convertedTokenInBalance The amount of input token that was converted\n /// @custom:event AssetTransferredToDestination Emitted when convertedTokenInBalance > 0, indicating\n /// the converted assets were transferred to the destination address\n function _postPrivateConversionHook(\n address comptroller,\n address tokenAddressIn,\n uint256 convertedTokenInBalance,\n address,\n uint256\n ) internal override {\n if (convertedTokenInBalance > 0) {\n emit AssetTransferredToDestination(\n destinationAddress,\n comptroller,\n tokenAddressIn,\n convertedTokenInBalance\n );\n }\n }\n\n /// @dev Update the assetsDirectTransfer mapping for destinationAddress\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\n /// @custom:event AssetsDirectTransferUpdated emits on success\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\n /// @custom:error DirectTransferBaseAssetNotAllowed thrown when an asset in `assets` is the `baseAsset`\n /// @custom:error SameAssetDirectTransferNotAllowed thrown when the value to set for an asset doesn't differs\n /// from its current value\n function _setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) internal {\n uint256 assetsLength = assets.length;\n\n if (assetsLength != values.length) {\n revert InputLengthMisMatch();\n }\n\n for (uint256 i; i < assetsLength; ++i) {\n if (assets[i] == baseAsset) {\n revert DirectTransferBaseAssetNotAllowed();\n }\n\n if (assetsDirectTransfer[assets[i]] == values[i]) {\n revert SameAssetDirectTransferNotAllowed(assets[i], values[i]);\n }\n\n assetsDirectTransfer[assets[i]] = values[i];\n emit AssetsDirectTransferUpdated(destinationAddress, assets[i], values[i]);\n }\n }\n\n /// @dev Sets the base asset for the contract\n /// @param baseAsset_ The new address of the base asset\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\n /// @custom:event BaseAssetUpdated is emitted on success\n function _setBaseAsset(address baseAsset_) internal {\n ensureNonzeroAddress(baseAsset_);\n\n if (baseAsset == baseAsset_) {\n revert SameBaseAssetNotAllowed();\n }\n\n emit BaseAssetUpdated(baseAsset, baseAsset_);\n baseAsset = baseAsset_;\n }\n\n /// @dev Get base asset address\n /// @return destinationBaseAsset Address of the base asset(baseAsset)\n function _getDestinationBaseAsset() internal view override returns (address destinationBaseAsset) {\n destinationBaseAsset = baseAsset;\n }\n}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 10000 + }, + "evmVersion": "paris", + "outputSelection": { + "*": { + "*": [ + "storageLayout", + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "evm.gasEstimates" + ], + "": ["ast"] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} diff --git a/deployments/bsctestnet/SingleTokenConverterImp.json b/deployments/bsctestnet/SingleTokenConverterImp.json index 31886958..409ee6c7 100644 --- a/deployments/bsctestnet/SingleTokenConverterImp.json +++ b/deployments/bsctestnet/SingleTokenConverterImp.json @@ -1,5 +1,5 @@ { - "address": "0x892A70c9D9f946c0CB2b148f40B95Ba0024e8968", + "address": "0xDAd6a8FC2e92Df60bD9580ea43b112C8680E141A", "abi": [ { "inputs": [], @@ -73,6 +73,11 @@ "name": "DeflationaryTokenNotSupported", "type": "error" }, + { + "inputs": [], + "name": "DirectTransferBaseAssetNotAllowed", + "type": "error" + }, { "inputs": [ { @@ -134,6 +139,27 @@ "name": "NonZeroIncentiveForPrivateConversion", "type": "error" }, + { + "inputs": [ + { + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "internalType": "bool", + "name": "value", + "type": "bool" + } + ], + "name": "SameAssetDirectTransferNotAllowed", + "type": "error" + }, + { + "inputs": [], + "name": "SameBaseAssetNotAllowed", + "type": "error" + }, { "inputs": [ { @@ -196,6 +222,31 @@ "name": "AssetTransferredToDestination", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "asset", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "value", + "type": "bool" + } + ], + "name": "AssetsDirectTransferUpdated", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -660,6 +711,25 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "assetsDirectTransfer", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [ { @@ -1191,6 +1261,24 @@ "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "assets", + "type": "address[]" + }, + { + "internalType": "bool[]", + "name": "values", + "type": "bool[]" + } + ], + "name": "setAssetsDirectTransfer", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [ { @@ -1381,42 +1469,52 @@ "type": "function" } ], - "transactionHash": "0xcd0a0f8412bcf4fd8b3df07b2d3238d3dd46d95978cd97417bbe5749355c2c83", + "transactionHash": "0xcc483a543bbf4f85bbdcea414ab9731eecebbeec0e88085c509a27e29c91128a", "receipt": { "to": null, - "from": "0x33C6476F88eeA28D7E7900F759B4597704Ef95B7", - "contractAddress": "0x892A70c9D9f946c0CB2b148f40B95Ba0024e8968", + "from": "0x616574729DF936d26F328a934401983cB189951c", + "contractAddress": "0xDAd6a8FC2e92Df60bD9580ea43b112C8680E141A", "transactionIndex": 0, - "gasUsed": "3704308", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000040400001000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0x244ebf2db5bc79ea6c19eb27b3135cd462d163e7631bbc060c6d581b996c92d0", - "transactionHash": "0xcd0a0f8412bcf4fd8b3df07b2d3238d3dd46d95978cd97417bbe5749355c2c83", + "gasUsed": "3964545", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000100000000000000000000000000000080000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000", + "blockHash": "0xced4e0c8dea851de0a0fc670b40bc1da75fd181711c926afd82056d10f035142", + "transactionHash": "0xcc483a543bbf4f85bbdcea414ab9731eecebbeec0e88085c509a27e29c91128a", "logs": [ { "transactionIndex": 0, - "blockNumber": 57755815, - "transactionHash": "0xcd0a0f8412bcf4fd8b3df07b2d3238d3dd46d95978cd97417bbe5749355c2c83", - "address": "0x892A70c9D9f946c0CB2b148f40B95Ba0024e8968", + "blockNumber": 62450191, + "transactionHash": "0xcc483a543bbf4f85bbdcea414ab9731eecebbeec0e88085c509a27e29c91128a", + "address": "0xDAd6a8FC2e92Df60bD9580ea43b112C8680E141A", "topics": ["0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498"], "data": "0x00000000000000000000000000000000000000000000000000000000000000ff", "logIndex": 0, - "blockHash": "0x244ebf2db5bc79ea6c19eb27b3135cd462d163e7631bbc060c6d581b996c92d0" + "blockHash": "0xced4e0c8dea851de0a0fc670b40bc1da75fd181711c926afd82056d10f035142" } ], - "blockNumber": 57755815, - "cumulativeGasUsed": "3704308", + "blockNumber": 62450191, + "cumulativeGasUsed": "3964545", "status": 1, "byzantium": true }, "args": [], - "numDeployments": 4, - "solcInputHash": "e2c9962896c0d2548025c54c4fbe3c77", - "metadata": "{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountInHigherThanMax\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountInMismatched\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountOutLowerThanMinRequired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountOutMismatched\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionConfigNotEnabled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionEnabledOnlyForPrivateConversions\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensActive\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensPaused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DeflationaryTokenNotSupported\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxIncentive\",\"type\":\"uint256\"}],\"name\":\"IncentiveTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InputLengthMisMatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientInputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientOutputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientPoolLiquidity\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidConverterNetwork\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidMinimumAmountToConvert\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidToAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenConfigAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NonZeroIncentiveForPrivateConversion\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"calledContract\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"methodSignature\",\"type\":\"string\"}],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddressNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroValueNotAllowed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"AssetTransferredToDestination\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldBaseAsset\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newBaseAsset\",\"type\":\"address\"}],\"name\":\"BaseAssetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"oldAccess\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"newAccess\",\"type\":\"uint8\"}],\"name\":\"ConversionConfigUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionResumed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldConverterNetwork\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"converterNetwork\",\"type\":\"address\"}],\"name\":\"ConverterNetworkAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldDestinationAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"}],\"name\":\"DestinationAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldMinAmountToConvert\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newMinAmountToConvert\",\"type\":\"uint256\"}],\"name\":\"MinAmountToConvertUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldAccessControlManager\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAccessControlManager\",\"type\":\"address\"}],\"name\":\"NewAccessControlManager\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"oldPriceOracle\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle\",\"type\":\"address\"}],\"name\":\"PriceOracleUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SweepToken\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MAX_INCENTIVE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"accessControlManager\",\"outputs\":[{\"internalType\":\"contract IAccessControlManagerV8\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"baseAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"conversionConfigurations\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"conversionPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"converterNetwork\",\"outputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"destinationAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"},{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minAmountToConvert\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"priceOracle\",\"outputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"}],\"name\":\"setAccessControlManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"}],\"name\":\"setBaseAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig\",\"name\":\"conversionConfig\",\"type\":\"tuple\"}],\"name\":\"setConversionConfig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"tokenAddressesOut\",\"type\":\"address[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig[]\",\"name\":\"conversionConfigs\",\"type\":\"tuple[]\"}],\"name\":\"setConversionConfigs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"converterNetwork_\",\"type\":\"address\"}],\"name\":\"setConverterNetwork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"}],\"name\":\"setDestination\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"setMinAmountToConvert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"}],\"name\":\"setPriceOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sweepToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"updateAssetsState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Venus\",\"custom:security-contact\":\"https://github.com/VenusProtocol/protocol-reserve#discussion\",\"events\":{\"Initialized(uint8)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"}},\"kind\":\"dev\",\"methods\":{\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"balanceOf(address)\":{\"params\":{\"tokenAddress\":\"Address of the token\"},\"returns\":{\"tokenBalance\":\"Balance of the token the contract has\"}},\"constructor\":{\"custom:oz-upgrades-unsafe-allow\":\"constructor\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissaAmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissaAmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\",\"custom:event\":\"Emits ConvertedForExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\",\"custom:event\":\"Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"getAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"getUpdatedAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getUpdatedAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"initialize(address,address,address,address,uint256)\":{\"params\":{\"accessControlManager_\":\"Access control manager contract address\",\"baseAsset_\":\"Address of the base asset\",\"destinationAddress_\":\"Address at all incoming tokens will transferred to\",\"minAmountToConvert_\":\"Minimum amount to convert\",\"priceOracle_\":\"Resilient oracle address\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pauseConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensPaused thrown when conversion is already paused\",\"custom:event\":\"Emits ConversionPaused on success\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"resumeConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensActive thrown when conversion is already active\",\"custom:event\":\"Emits ConversionResumed on success\"},\"setAccessControlManager(address)\":{\"custom:access\":\"Only Governance\",\"custom:event\":\"Emits NewAccessControlManager event\",\"details\":\"Admin function to set address of AccessControlManager\",\"params\":{\"accessControlManager_\":\"The new address of the AccessControlManager\"}},\"setBaseAsset(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"baseAsset_\":\"The new address of the base asset\"}},\"setConversionConfig(address,address,(uint256,uint8))\":{\"custom:access\":\"Controlled by AccessControlManager\",\"custom:error\":\"Unauthorized error is thrown when the call is not authorized by AccessControlManagerZeroAddressNotAllowed is thrown when pool registry address is zeroNonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\",\"custom:event\":\"Emits ConversionConfigUpdated event on success\",\"params\":{\"conversionConfig\":\"ConversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressOut\":\"Address of tokenOut\"}},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"custom:error\":\"InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\",\"params\":{\"conversionConfigs\":\"Array of conversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressesOut\":\"Array of addresses of tokenOut\"}},\"setConverterNetwork(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"converterNetwork_\":\"The converterNetwork address to be set\"}},\"setDestination(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"destinationAddress_\":\"The new destination address to be set\"}},\"setMinAmountToConvert(uint256)\":{\"custom:access\":\"Only Governance\",\"params\":{\"minAmountToConvert_\":\"Min amount to convert\"}},\"setPriceOracle(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"priceOracle_\":\"Address of the new price oracle to set\"}},\"sweepToken(address,address,uint256)\":{\"custom:access\":\"Only Governance\",\"custom:error\":\"ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\",\"custom:event\":\"Emits SweepToken event on success\",\"params\":{\"amount\":\"The amount to transfer\",\"to\":\"The address to which tokens will be transferred\",\"tokenAddress\":\"The address of the ERC-20 token to sweep\"}},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner.\"},\"updateAssetsState(address,address)\":{\"details\":\"This function is called by protocolShareReservecall _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\",\"params\":{\"asset\":\"Asset address\",\"comptroller\":\"Comptroller address (pool)\"}}},\"title\":\"SingleTokenConverter\",\"version\":1},\"userdoc\":{\"errors\":{\"AmountInHigherThanMax(uint256,uint256)\":[{\"notice\":\"Thrown when amountIn is higher than amountInMax\"}],\"AmountInMismatched()\":[{\"notice\":\"Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\"}],\"AmountOutLowerThanMinRequired(uint256,uint256)\":[{\"notice\":\"Thrown when amountOut is lower than amountOutMin\"}],\"AmountOutMismatched()\":[{\"notice\":\"Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\"}],\"ConversionConfigNotEnabled()\":[{\"notice\":\"Thrown when conversion is disabled or config does not exist for given pair\"}],\"ConversionEnabledOnlyForPrivateConversions()\":[{\"notice\":\"Thrown when conversion is enabled only for private conversions\"}],\"ConversionTokensActive()\":[{\"notice\":\"Thrown when conversion is Active\"}],\"ConversionTokensPaused()\":[{\"notice\":\"Thrown when conversion is paused\"}],\"DeflationaryTokenNotSupported()\":[{\"notice\":\"Thrown when using convertForExactTokens deflationary tokens\"}],\"IncentiveTooHigh(uint256,uint256)\":[{\"notice\":\"Thrown when incentive is higher than the MAX_INCENTIVE\"}],\"InputLengthMisMatch()\":[{\"notice\":\"Thrown when there is a mismatch in the length of input arrays\"}],\"InsufficientInputAmount()\":[{\"notice\":\"Thrown when given input amount is zero\"}],\"InsufficientOutputAmount()\":[{\"notice\":\"Thrown when given output amount is zero\"}],\"InsufficientPoolLiquidity()\":[{\"notice\":\"Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\"}],\"InvalidConverterNetwork()\":[{\"notice\":\"When address of the ConverterNetwork is not set or Zero address\"}],\"InvalidMinimumAmountToConvert()\":[{\"notice\":\"Thrown when minimum amount to convert is zero\"}],\"InvalidToAddress()\":[{\"notice\":\"Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\"}],\"InvalidTokenConfigAddresses()\":[{\"notice\":\"Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\"}],\"NonZeroIncentiveForPrivateConversion()\":[{\"notice\":\"Thrown when trying to set non zero incentive for private conversion\"}],\"Unauthorized(address,address,string)\":[{\"notice\":\"Thrown when the action is prohibited by AccessControlManager\"}],\"ZeroAddressNotAllowed()\":[{\"notice\":\"Thrown if the supplied address is a zero address where it is not allowed\"}],\"ZeroValueNotAllowed()\":[{\"notice\":\"Thrown if the supplied value is 0 where it is not allowed\"}]},\"events\":{\"AssetTransferredToDestination(address,address,address,uint256)\":{\"notice\":\"Emmitted after the funds transferred to the destination address\"},\"BaseAssetUpdated(address,address)\":{\"notice\":\"Emitted when base asset is updated\"},\"ConversionConfigUpdated(address,address,uint256,uint256,uint8,uint8)\":{\"notice\":\"Emitted when config is updated for tokens pair\"},\"ConversionPaused(address)\":{\"notice\":\"Emitted when conversion is paused\"},\"ConversionResumed(address)\":{\"notice\":\"Emitted when conversion is unpaused\"},\"ConvertedExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens\"},\"ConvertedExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\"},\"ConvertedForExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens\"},\"ConvertedForExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\"},\"ConverterNetworkAddressUpdated(address,address)\":{\"notice\":\"Emitted when converterNetwork address is updated\"},\"DestinationAddressUpdated(address,address)\":{\"notice\":\"Emitted when destination address is updated\"},\"MinAmountToConvertUpdated(uint256,uint256)\":{\"notice\":\"Emitted when minimum amount to convert is updated\"},\"NewAccessControlManager(address,address)\":{\"notice\":\"Emitted when access control manager contract address is changed\"},\"PriceOracleUpdated(address,address)\":{\"notice\":\"Emitted when price oracle address is updated\"},\"SweepToken(address,address,uint256)\":{\"notice\":\"Event emitted when tokens are swept\"}},\"kind\":\"user\",\"methods\":{\"MAX_INCENTIVE()\":{\"notice\":\"Maximum incentive could be\"},\"accessControlManager()\":{\"notice\":\"Returns the address of the access control manager contract\"},\"balanceOf(address)\":{\"notice\":\"Get the balance for specific token\"},\"baseAsset()\":{\"notice\":\"Address of the base asset token\"},\"conversionConfigurations(address,address)\":{\"notice\":\"conversion configurations for the existing pairs\"},\"conversionPaused()\":{\"notice\":\"Boolean for if conversion is paused\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract, otherwise the amount is adjusted\"},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted. The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\"},\"converterNetwork()\":{\"notice\":\"Address of the converterNetwork contract\"},\"destinationAddress()\":{\"notice\":\"Address that all incoming tokens are transferred to\"},\"getAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut. This function does not account for potential token transfer fees(in case of deflationary tokens)\"},\"getAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn. This function does not account for potential token transfer fees(in case of deflationary tokens)The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\"},\"getUpdatedAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\"},\"getUpdatedAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\"},\"minAmountToConvert()\":{\"notice\":\"Min amount to convert for private conversions. Defined in USD, with 18 decimals\"},\"pauseConversion()\":{\"notice\":\"Pause conversion of tokens\"},\"priceOracle()\":{\"notice\":\"Venus price oracle contract\"},\"resumeConversion()\":{\"notice\":\"Resume conversion of tokens.\"},\"setAccessControlManager(address)\":{\"notice\":\"Sets the address of AccessControlManager\"},\"setBaseAsset(address)\":{\"notice\":\"Sets the base asset for the contract\"},\"setConversionConfig(address,address,(uint256,uint8))\":{\"notice\":\"Set the configuration for new or existing conversion pair\"},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"notice\":\"Batch sets the conversion configurations\"},\"setConverterNetwork(address)\":{\"notice\":\"Sets a converter network contract address\"},\"setDestination(address)\":{\"notice\":\"Sets a new destination address\"},\"setMinAmountToConvert(uint256)\":{\"notice\":\"Min amount to convert setter\"},\"setPriceOracle(address)\":{\"notice\":\"Sets a new price oracle\"},\"sweepToken(address,address,uint256)\":{\"notice\":\"To sweep ERC20 tokens and transfer them to user(to address)\"},\"updateAssetsState(address,address)\":{\"notice\":\"This method updated the states of this contract after getting funds from PSR after settling the amount(if any) through privateConversion between converters\"}},\"notice\":\"SingleTokenConverter used for token conversions and sends received tokens\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/TokenConverter/SingleTokenConverter.sol\":\"SingleTokenConverter\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./OwnableUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership} and {acceptOwnership}.\\n *\\n * This module is used through inheritance. It will make available all functions\\n * from parent (Ownable).\\n */\\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\\n function __Ownable2Step_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable2Step_init_unchained() internal onlyInitializing {\\n }\\n address private _pendingOwner;\\n\\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Returns the address of the pending owner.\\n */\\n function pendingOwner() public view virtual returns (address) {\\n return _pendingOwner;\\n }\\n\\n /**\\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual override onlyOwner {\\n _pendingOwner = newOwner;\\n emit OwnershipTransferStarted(owner(), newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual override {\\n delete _pendingOwner;\\n super._transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev The new owner accepts the ownership transfer.\\n */\\n function acceptOwnership() public virtual {\\n address sender = _msgSender();\\n require(pendingOwner() == sender, \\\"Ownable2Step: caller is not the new owner\\\");\\n _transferOwnership(sender);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x84efb8889801b0ac817324aff6acc691d07bbee816b671817132911d287a8c63\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n function __Ownable_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable_init_unchained() internal onlyInitializing {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby disabling any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x4075622496acc77fd6d4de4cc30a8577a744d5c75afad33fdeacf1704d6eda98\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts.\\n *\\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n * constructor.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n * are added through upgrades and that require initialization.\\n *\\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n * cannot be nested. If one is invoked in the context of another, execution will revert.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n *\\n * WARNING: setting the version to 255 will prevent any future reinitialization.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n *\\n * Emits an {Initialized} event the first time it is successfully executed.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized != type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n\\n /**\\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n */\\n function _getInitializedVersion() internal view returns (uint8) {\\n return _initialized;\\n }\\n\\n /**\\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n */\\n function _isInitializing() internal view returns (bool) {\\n return _initializing;\\n }\\n}\\n\",\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state.\\n */\\n function __Pausable_init() internal onlyInitializing {\\n __Pausable_init_unchained();\\n }\\n\\n function __Pausable_init_unchained() internal onlyInitializing {\\n _paused = false;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused() {\\n _requireNotPaused();\\n _;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier whenPaused() {\\n _requirePaused();\\n _;\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused() public view virtual returns (bool) {\\n return _paused;\\n }\\n\\n /**\\n * @dev Throws if the contract is paused.\\n */\\n function _requireNotPaused() internal view virtual {\\n require(!paused(), \\\"Pausable: paused\\\");\\n }\\n\\n /**\\n * @dev Throws if the contract is not paused.\\n */\\n function _requirePaused() internal view virtual {\\n require(paused(), \\\"Pausable: not paused\\\");\\n }\\n\\n /**\\n * @dev Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(_msgSender());\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n function __ReentrancyGuard_init() internal onlyInitializing {\\n __ReentrancyGuard_init_unchained();\\n }\\n\\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == _ENTERED;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xb82ef33f43b6b96109687d91b39c94573fdccaaa423fe28e8ba0977b31c023e0\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20PermitUpgradeable {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xd60f939a3ca0199014d079b4dd66aa757954334947d81eb5c1d35d7a83061ab3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\nimport \\\"../extensions/IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20Upgradeable {\\n using AddressUpgradeable for address;\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\\n * Revert on invalid signature.\\n */\\n function safePermit(\\n IERC20PermitUpgradeable token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return\\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));\\n }\\n}\\n\",\"keccak256\":\"0x23b997be73d3dd46885262704f0f8cfc7273fdadfe303d37969a9561373972b5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n *\\n * Furthermore, `isContract` will also return true if the target contract within\\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n * which only has an effect at the end of a transaction.\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal onlyInitializing {\\n }\\n\\n function __Context_init_unchained() internal onlyInitializing {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl {\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\"},\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\\\";\\n\\nimport \\\"./IAccessControlManagerV8.sol\\\";\\n\\n/**\\n * @title AccessControlledV8\\n * @author Venus\\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.8.13)\\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\\n */\\nabstract contract AccessControlledV8 is Initializable, Ownable2StepUpgradeable {\\n /// @notice Access control manager contract\\n IAccessControlManagerV8 private _accessControlManager;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n\\n /// @notice Emitted when access control manager contract address is changed\\n event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\\n\\n /// @notice Thrown when the action is prohibited by AccessControlManager\\n error Unauthorized(address sender, address calledContract, string methodSignature);\\n\\n function __AccessControlled_init(address accessControlManager_) internal onlyInitializing {\\n __Ownable2Step_init();\\n __AccessControlled_init_unchained(accessControlManager_);\\n }\\n\\n function __AccessControlled_init_unchained(address accessControlManager_) internal onlyInitializing {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Sets the address of AccessControlManager\\n * @dev Admin function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n * @custom:event Emits NewAccessControlManager event\\n * @custom:access Only Governance\\n */\\n function setAccessControlManager(address accessControlManager_) external onlyOwner {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Returns the address of the access control manager contract\\n */\\n function accessControlManager() external view returns (IAccessControlManagerV8) {\\n return _accessControlManager;\\n }\\n\\n /**\\n * @dev Internal function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n */\\n function _setAccessControlManager(address accessControlManager_) internal {\\n require(address(accessControlManager_) != address(0), \\\"invalid acess control manager address\\\");\\n address oldAccessControlManager = address(_accessControlManager);\\n _accessControlManager = IAccessControlManagerV8(accessControlManager_);\\n emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\\n }\\n\\n /**\\n * @notice Reverts if the call is not allowed by AccessControlManager\\n * @param signature Method signature\\n */\\n function _checkAccessAllowed(string memory signature) internal view {\\n bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\\n\\n if (!isAllowedToCall) {\\n revert Unauthorized(msg.sender, address(this), signature);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0dcf283925f4dddc23ca0ee71d2cb96a9dd6e4cf08061b69fde1697ea39dc514\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/access/IAccessControl.sol\\\";\\n\\n/**\\n * @title IAccessControlManagerV8\\n * @author Venus\\n * @notice Interface implemented by the `AccessControlManagerV8` contract.\\n */\\ninterface IAccessControlManagerV8 is IAccessControl {\\n function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\\n\\n function revokeCallPermission(\\n address contractAddress,\\n string calldata functionSig,\\n address accountToRevoke\\n ) external;\\n\\n function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\\n\\n function hasPermission(\\n address account,\\n address contractAddress,\\n string calldata functionSig\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xaa29b098440d0b3a131c5ecdf25ce548790c1b5ac7bf9b5c0264b6af6f7a1e0b\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/ResilientOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\n// SPDX-FileCopyrightText: 2022 Venus\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\nimport \\\"./interfaces/VBep20Interface.sol\\\";\\nimport \\\"./interfaces/OracleInterface.sol\\\";\\nimport \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\n\\n/**\\n * @title ResilientOracle\\n * @author Venus\\n * @notice The Resilient Oracle is the main contract that the protocol uses to fetch prices of assets.\\n *\\n * DeFi protocols are vulnerable to price oracle failures including oracle manipulation and incorrectly\\n * reported prices. If only one oracle is used, this creates a single point of failure and opens a vector\\n * for attacking the protocol.\\n *\\n * The Resilient Oracle uses multiple sources and fallback mechanisms to provide accurate prices and protect\\n * the protocol from oracle attacks. Currently it includes integrations with Chainlink, Pyth, Binance Oracle\\n * and TWAP (Time-Weighted Average Price) oracles. TWAP uses PancakeSwap as the on-chain price source.\\n *\\n * For every market (vToken) we configure the main, pivot and fallback oracles. The oracles are configured per\\n * vToken's underlying asset address. The main oracle oracle is the most trustworthy price source, the pivot\\n * oracle is used as a loose sanity checker and the fallback oracle is used as a backup price source.\\n *\\n * To validate prices returned from two oracles, we use an upper and lower bound ratio that is set for every\\n * market. The upper bound ratio represents the deviation between reported price (the price that\\u2019s being\\n * validated) and the anchor price (the price we are validating against) above which the reported price will\\n * be invalidated. The lower bound ratio presents the deviation between reported price and anchor price below\\n * which the reported price will be invalidated. So for oracle price to be considered valid the below statement\\n * should be true:\\n\\n```\\nanchorRatio = anchorPrice/reporterPrice\\nisValid = anchorRatio <= upperBoundAnchorRatio && anchorRatio >= lowerBoundAnchorRatio\\n```\\n\\n * In most cases, Chainlink is used as the main oracle, TWAP or Pyth oracles are used as the pivot oracle depending\\n * on which supports the given market and Binance oracle is used as the fallback oracle. For some markets we may\\n * use Pyth or TWAP as the main oracle if the token price is not supported by Chainlink or Binance oracles.\\n *\\n * For a fetched price to be valid it must be positive and not stagnant. If the price is invalid then we consider the\\n * oracle to be stagnant and treat it like it's disabled.\\n */\\ncontract ResilientOracle is PausableUpgradeable, AccessControlledV8, ResilientOracleInterface {\\n /**\\n * @dev Oracle roles:\\n * **main**: The most trustworthy price source\\n * **pivot**: Price oracle used as a loose sanity checker\\n * **fallback**: The backup source when main oracle price is invalidated\\n */\\n enum OracleRole {\\n MAIN,\\n PIVOT,\\n FALLBACK\\n }\\n\\n struct TokenConfig {\\n /// @notice asset address\\n address asset;\\n /// @notice `oracles` stores the oracles based on their role in the following order:\\n /// [main, pivot, fallback],\\n /// It can be indexed with the corresponding enum OracleRole value\\n address[3] oracles;\\n /// @notice `enableFlagsForOracles` stores the enabled state\\n /// for each oracle in the same order as `oracles`\\n bool[3] enableFlagsForOracles;\\n }\\n\\n uint256 public constant INVALID_PRICE = 0;\\n\\n /// @notice Native market address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable nativeMarket;\\n\\n /// @notice VAI address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable vai;\\n\\n /// @notice Set this as asset address for Native token on each chain.This is the underlying for vBNB (on bsc)\\n /// and can serve as any underlying asset of a market that supports native tokens\\n address public constant NATIVE_TOKEN_ADDR = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\\n\\n /// @notice Bound validator contract address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n BoundValidatorInterface public immutable boundValidator;\\n\\n mapping(address => TokenConfig) private tokenConfigs;\\n\\n event TokenConfigAdded(\\n address indexed asset,\\n address indexed mainOracle,\\n address indexed pivotOracle,\\n address fallbackOracle\\n );\\n\\n /// Event emitted when an oracle is set\\n event OracleSet(address indexed asset, address indexed oracle, uint256 indexed role);\\n\\n /// Event emitted when an oracle is enabled or disabled\\n event OracleEnabled(address indexed asset, uint256 indexed role, bool indexed enable);\\n\\n /**\\n * @notice Checks whether an address is null or not\\n */\\n modifier notNullAddress(address someone) {\\n if (someone == address(0)) revert(\\\"can't be zero address\\\");\\n _;\\n }\\n\\n /**\\n * @notice Checks whether token config exists by checking whether asset is null address\\n * @dev address can't be null, so it's suitable to be used to check the validity of the config\\n * @param asset asset address\\n */\\n modifier checkTokenConfigExistence(address asset) {\\n if (tokenConfigs[asset].asset == address(0)) revert(\\\"token config must exist\\\");\\n _;\\n }\\n\\n /// @notice Constructor for the implementation contract. Sets immutable variables.\\n /// @dev nativeMarketAddress can be address(0) if on the chain we do not support native market\\n /// (e.g vETH on ethereum would not be supported, only vWETH)\\n /// @param nativeMarketAddress The address of a native market (for bsc it would be vBNB address)\\n /// @param vaiAddress The address of the VAI token (if there is VAI on the deployed chain).\\n /// Set to address(0) of VAI is not existent.\\n /// @param _boundValidator Address of the bound validator contract\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor(\\n address nativeMarketAddress,\\n address vaiAddress,\\n BoundValidatorInterface _boundValidator\\n ) notNullAddress(address(_boundValidator)) {\\n nativeMarket = nativeMarketAddress;\\n vai = vaiAddress;\\n boundValidator = _boundValidator;\\n\\n _disableInitializers();\\n }\\n\\n /**\\n * @notice Initializes the contract admin and sets the BoundValidator contract address\\n * @param accessControlManager_ Address of the access control manager contract\\n */\\n function initialize(address accessControlManager_) external initializer {\\n __AccessControlled_init(accessControlManager_);\\n __Pausable_init();\\n }\\n\\n /**\\n * @notice Pauses oracle\\n * @custom:access Only Governance\\n */\\n function pause() external {\\n _checkAccessAllowed(\\\"pause()\\\");\\n _pause();\\n }\\n\\n /**\\n * @notice Unpauses oracle\\n * @custom:access Only Governance\\n */\\n function unpause() external {\\n _checkAccessAllowed(\\\"unpause()\\\");\\n _unpause();\\n }\\n\\n /**\\n * @notice Batch sets token configs\\n * @param tokenConfigs_ Token config array\\n * @custom:access Only Governance\\n * @custom:error Throws a length error if the length of the token configs array is 0\\n */\\n function setTokenConfigs(TokenConfig[] memory tokenConfigs_) external {\\n if (tokenConfigs_.length == 0) revert(\\\"length can't be 0\\\");\\n uint256 numTokenConfigs = tokenConfigs_.length;\\n for (uint256 i; i < numTokenConfigs; ) {\\n setTokenConfig(tokenConfigs_[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /**\\n * @notice Sets oracle for a given asset and role.\\n * @dev Supplied asset **must** exist and main oracle may not be null\\n * @param asset Asset address\\n * @param oracle Oracle address\\n * @param role Oracle role\\n * @custom:access Only Governance\\n * @custom:error Null address error if main-role oracle address is null\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n * @custom:event Emits OracleSet event with asset address, oracle address and role of the oracle for the asset\\n */\\n function setOracle(\\n address asset,\\n address oracle,\\n OracleRole role\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"setOracle(address,address,uint8)\\\");\\n if (oracle == address(0) && role == OracleRole.MAIN) revert(\\\"can't set zero address to main oracle\\\");\\n tokenConfigs[asset].oracles[uint256(role)] = oracle;\\n emit OracleSet(asset, oracle, uint256(role));\\n }\\n\\n /**\\n * @notice Enables/ disables oracle for the input asset. Token config for the input asset **must** exist\\n * @dev Configuration for the asset **must** already exist and the asset cannot be 0 address\\n * @param asset Asset address\\n * @param role Oracle role\\n * @param enable Enabled boolean of the oracle\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n */\\n function enableOracle(\\n address asset,\\n OracleRole role,\\n bool enable\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"enableOracle(address,uint8,bool)\\\");\\n tokenConfigs[asset].enableFlagsForOracles[uint256(role)] = enable;\\n emit OracleEnabled(asset, uint256(role), enable);\\n }\\n\\n /**\\n * @notice Updates the TWAP pivot oracle price.\\n * @dev This function should always be called before calling getUnderlyingPrice\\n * @param vToken vToken address\\n */\\n function updatePrice(address vToken) external override {\\n address asset = _getUnderlyingAsset(vToken);\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @notice Updates the pivot oracle price. Currently using TWAP\\n * @dev This function should always be called before calling getPrice\\n * @param asset asset address\\n */\\n function updateAssetPrice(address asset) external {\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @dev Gets token config by asset address\\n * @param asset asset address\\n * @return tokenConfig Config for the asset\\n */\\n function getTokenConfig(address asset) external view returns (TokenConfig memory) {\\n return tokenConfigs[asset];\\n }\\n\\n /**\\n * @notice Gets price of the underlying asset for a given vToken. Validation flow:\\n * - Check if the oracle is paused globally\\n * - Validate price from main oracle against pivot oracle\\n * - Validate price from fallback oracle against pivot oracle if the first validation failed\\n * - Validate price from main oracle against fallback oracle if the second validation failed\\n * In the case that the pivot oracle is not available but main price is available and validation is successful,\\n * main oracle price is returned.\\n * @param vToken vToken address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getUnderlyingPrice(address vToken) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n\\n address asset = _getUnderlyingAsset(vToken);\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Gets price of the asset\\n * @param asset asset address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getPrice(address asset) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Sets/resets single token configs.\\n * @dev main oracle **must not** be a null address\\n * @param tokenConfig Token config struct\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress is thrown if asset address is null\\n * @custom:error NotNullAddress is thrown if main-role oracle address for asset is null\\n * @custom:event Emits TokenConfigAdded event when the asset config is set successfully by the authorized account\\n */\\n function setTokenConfig(\\n TokenConfig memory tokenConfig\\n ) public notNullAddress(tokenConfig.asset) notNullAddress(tokenConfig.oracles[uint256(OracleRole.MAIN)]) {\\n _checkAccessAllowed(\\\"setTokenConfig(TokenConfig)\\\");\\n\\n tokenConfigs[tokenConfig.asset] = tokenConfig;\\n emit TokenConfigAdded(\\n tokenConfig.asset,\\n tokenConfig.oracles[uint256(OracleRole.MAIN)],\\n tokenConfig.oracles[uint256(OracleRole.PIVOT)],\\n tokenConfig.oracles[uint256(OracleRole.FALLBACK)]\\n );\\n }\\n\\n /**\\n * @notice Gets oracle and enabled status by asset address\\n * @param asset asset address\\n * @param role Oracle role\\n * @return oracle Oracle address based on role\\n * @return enabled Enabled flag of the oracle based on token config\\n */\\n function getOracle(address asset, OracleRole role) public view returns (address oracle, bool enabled) {\\n oracle = tokenConfigs[asset].oracles[uint256(role)];\\n enabled = tokenConfigs[asset].enableFlagsForOracles[uint256(role)];\\n }\\n\\n function _getPrice(address asset) internal view returns (uint256) {\\n uint256 pivotPrice = INVALID_PRICE;\\n\\n // Get pivot oracle price, Invalid price if not available or error\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracleEnabled && pivotOracle != address(0)) {\\n try OracleInterface(pivotOracle).getPrice(asset) returns (uint256 pricePivot) {\\n pivotPrice = pricePivot;\\n } catch {}\\n }\\n\\n // Compare main price and pivot price, return main price and if validation was successful\\n // note: In case pivot oracle is not available but main price is available and\\n // validation is successful, the main oracle price is returned.\\n (uint256 mainPrice, bool validatedPivotMain) = _getMainOraclePrice(\\n asset,\\n pivotPrice,\\n pivotOracleEnabled && pivotOracle != address(0)\\n );\\n if (mainPrice != INVALID_PRICE && validatedPivotMain) return mainPrice;\\n\\n // Compare fallback and pivot if main oracle comparision fails with pivot\\n // Return fallback price when fallback price is validated successfully with pivot oracle\\n (uint256 fallbackPrice, bool validatedPivotFallback) = _getFallbackOraclePrice(asset, pivotPrice);\\n if (fallbackPrice != INVALID_PRICE && validatedPivotFallback) return fallbackPrice;\\n\\n // Lastly compare main price and fallback price\\n if (\\n mainPrice != INVALID_PRICE &&\\n fallbackPrice != INVALID_PRICE &&\\n boundValidator.validatePriceWithAnchorPrice(asset, mainPrice, fallbackPrice)\\n ) {\\n return mainPrice;\\n }\\n\\n revert(\\\"invalid resilient oracle price\\\");\\n }\\n\\n /**\\n * @notice Gets a price for the provided asset\\n * @dev This function won't revert when price is 0, because the fallback oracle may still be\\n * able to fetch a correct price\\n * @param asset asset address\\n * @param pivotPrice Pivot oracle price\\n * @param pivotEnabled If pivot oracle is not empty and enabled\\n * @return price USD price in scaled decimals\\n * e.g. asset decimals is 8 then price is returned as 10**18 * 10**(18-8) = 10**28 decimals\\n * @return pivotValidated Boolean representing if the validation of main oracle price\\n * and pivot oracle price were successful\\n * @custom:error Invalid price error is thrown if main oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if main oracle is not enabled or main oracle\\n * address is null\\n */\\n function _getMainOraclePrice(\\n address asset,\\n uint256 pivotPrice,\\n bool pivotEnabled\\n ) internal view returns (uint256, bool) {\\n (address mainOracle, bool mainOracleEnabled) = getOracle(asset, OracleRole.MAIN);\\n if (mainOracleEnabled && mainOracle != address(0)) {\\n try OracleInterface(mainOracle).getPrice(asset) returns (uint256 mainOraclePrice) {\\n if (!pivotEnabled) {\\n return (mainOraclePrice, true);\\n }\\n if (pivotPrice == INVALID_PRICE) {\\n return (mainOraclePrice, false);\\n }\\n return (\\n mainOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, mainOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function won't revert when the price is 0 because getPrice checks if price is > 0\\n * @param asset asset address\\n * @return price USD price in 18 decimals\\n * @return pivotValidated Boolean representing if the validation of fallback oracle price\\n * and pivot oracle price were successfully\\n * @custom:error Invalid price error is thrown if fallback oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if fallback oracle is not enabled or fallback oracle\\n * address is null\\n */\\n function _getFallbackOraclePrice(address asset, uint256 pivotPrice) private view returns (uint256, bool) {\\n (address fallbackOracle, bool fallbackEnabled) = getOracle(asset, OracleRole.FALLBACK);\\n if (fallbackEnabled && fallbackOracle != address(0)) {\\n try OracleInterface(fallbackOracle).getPrice(asset) returns (uint256 fallbackOraclePrice) {\\n if (pivotPrice == INVALID_PRICE) {\\n return (fallbackOraclePrice, false);\\n }\\n return (\\n fallbackOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, fallbackOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function returns the underlying asset of a vToken\\n * @param vToken vToken address\\n * @return asset underlying asset address\\n */\\n function _getUnderlyingAsset(address vToken) private view notNullAddress(vToken) returns (address asset) {\\n if (vToken == nativeMarket) {\\n asset = NATIVE_TOKEN_ADDR;\\n } else if (vToken == vai) {\\n asset = vai;\\n } else {\\n asset = VBep20Interface(vToken).underlying();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xdaaa90daa8ca5bda477729aaa5d5ff3e5305635baec1799a368d564ae2a13c4c\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\ninterface OracleInterface {\\n function getPrice(address asset) external view returns (uint256);\\n}\\n\\ninterface ResilientOracleInterface is OracleInterface {\\n function updatePrice(address vToken) external;\\n\\n function updateAssetPrice(address asset) external;\\n\\n function getUnderlyingPrice(address vToken) external view returns (uint256);\\n}\\n\\ninterface TwapInterface is OracleInterface {\\n function updateTwap(address asset) external returns (uint256);\\n}\\n\\ninterface BoundValidatorInterface {\\n function validatePriceWithAnchorPrice(\\n address asset,\\n uint256 reporterPrice,\\n uint256 anchorPrice\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x2432799b0d824fc701beb4c30146e912b9aeecf77b5c1635dde6c5fbe6bfc3a7\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/VBep20Interface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\ninterface VBep20Interface is IERC20Metadata {\\n /**\\n * @notice Underlying asset for this VToken\\n */\\n function underlying() external view returns (address);\\n}\\n\",\"keccak256\":\"0x6e71c3df86501df5c0e4bace1333c0c91f9f9cced252a54fb99eeda219b789d5\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/constants.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\n/// @dev Base unit for computations, usually used in scaling (multiplications, divisions)\\nuint256 constant EXP_SCALE = 1e18;\\n\\n/// @dev A unit (literal one) in EXP_SCALE, usually used in additions/subtractions\\nuint256 constant MANTISSA_ONE = EXP_SCALE;\\n\\n/// @dev The approximate number of seconds per year\\nuint256 constant SECONDS_PER_YEAR = 31_536_000;\\n\",\"keccak256\":\"0x14de93ead464da249af31bea0e3bcfb62ec693bea3475fb4d90f055ac81dc5eb\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/validators.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\n/// @notice Thrown if the supplied address is a zero address where it is not allowed\\nerror ZeroAddressNotAllowed();\\n\\n/// @notice Thrown if the supplied value is 0 where it is not allowed\\nerror ZeroValueNotAllowed();\\n\\n/// @notice Checks if the provided address is nonzero, reverts otherwise\\n/// @param address_ Address to check\\n/// @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address\\nfunction ensureNonzeroAddress(address address_) pure {\\n if (address_ == address(0)) {\\n revert ZeroAddressNotAllowed();\\n }\\n}\\n\\n/// @notice Checks if the provided value is nonzero, reverts otherwise\\n/// @param value_ Value to check\\n/// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\nfunction ensureNonzeroValue(uint256 value_) pure {\\n if (value_ == 0) {\\n revert ZeroValueNotAllowed();\\n }\\n}\\n\",\"keccak256\":\"0xdb88e14d50dd21889ca3329d755673d022c47e8da005b6a545c7f69c2c4b7b86\",\"license\":\"BSD-3-Clause\"},\"contracts/Interfaces/IConverterNetwork.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { IAbstractTokenConverter } from \\\"../TokenConverter/IAbstractTokenConverter.sol\\\";\\n\\n/**\\n * @title IConverterNetwork\\n * @author Venus\\n * @notice Interface implemented by `ConverterNetwork`.\\n */\\ninterface IConverterNetwork {\\n /// @notice Adds new converter to the array\\n /// @param _tokenConverter Address of the token converter\\n function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Removes converter from the array\\n /// @param _tokenConverter Address of the token converter\\n function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice This function returns the array containing all the converters addresses\\n /// @return Array containing all the converters addresses\\n function getAllConverters() external view returns (IAbstractTokenConverter[] memory);\\n\\n /// @notice This function checks for given address is converter or not\\n /// @param _tokenConverter Address of the token converter\\n /// @return boolean true if given address is converter otherwise false\\n function isTokenConverter(address _tokenConverter) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xd9a747f176d9b9de220331b87ed711cc2bd594a118b538a35f3c47060bff7a8b\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/AbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { ReentrancyGuardUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { AccessControlledV8 } from \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress, ensureNonzeroValue } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\nimport { MANTISSA_ONE, EXP_SCALE } from \\\"@venusprotocol/solidity-utilities/contracts/constants.sol\\\";\\n\\nimport { IAbstractTokenConverter } from \\\"./IAbstractTokenConverter.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @title AbstractTokenConverter\\n/// @author Venus\\n/// @notice Abstract contract will be extended by SingleTokenConverter and RiskFundConverter\\n/*\\n * This contract specifies four functions for converting tokens, each applicable under following circumstances:\\n *\\n * Case I: TokenIn -> deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions supporting fees can only be utilized to convert tokens which are:\\n * a. convertExactTokensSupportingFeeOnTransferTokens\\n * b. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case II: TokenIn -> deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions supporting fee can only be utilized to convert tokens which are:\\n * similar to Case I.\\n *\\n * Case III: TokenIn -> non-deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * a. convertExactTokens\\n * b. convertForExactTokens\\n * c. convertExactTokensSupportingFeeOnTransferTokens\\n * d. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case IV: TokenIn -> non-deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * similar to Case III.\\n *\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n * Example 1:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInAmount - 100\\n * tokenOutMinAmount - minimum amount desired by the user(let's say 70)\\n * Here user can use `convertExactTokens` or `convertExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertExactTokens` is used).\\n * Now first tokenInAddress tokens will be transferred from the user to the contract, on the basis of amount\\n * received(as tokenInAddress can be deflationary token) tokenAmountOut will be calculated and will be transferred\\n * to the user and if amount sent is less than tokenOutMinAmount, tx will revert. If amount sent is satisfied(let's say\\n * 80 or even 70) then at last the actual amount received and the amount that was supposed to be received by the contract will\\n * be compared, if they differ then the whole tx will revert as user was supposed to use `convertExactTokensSupportingFeeOnTransferTokens`\\n * function for tokenIn as deflationary token.\\n *\\n * Example 2:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInMaxAmount - maximum amount user is willing to provide(let's say 100)\\n * tokenOutAmount - 70\\n * Here user can use `convertForExactTokens` or `convertForExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertForExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertForExactTokens` is used),\\n * which on the basis of tokenOutAmount provided will calculate tokenInAmount based on the tokens prices and will transfer\\n * tokens from the user to the contract, now the actual amount received(as tokenInAddress can be deflationary token) will be\\n * compared with tokenInMaxAmount if it is greater, tx will revert. If In amount is satisfied(let's say 90 or even 100) then\\n * new tokenOutAmount will be calculated, and tokenOutAddress tokens will be transferred to the user, but at last the\\n * old tokenOutAmount and new tokenOutAmount will be compared and if they differ whole tx will revert, because user was\\n * supposed to use `convertForExactTokensSupportingFeeOnTransferTokens` function for tokenIn as deflationary token.\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n *\\n * This contract also supports private conversion between the converters:\\n * Private conversions:\\n * Private conversions is designed in order to convert the maximum amount of tokens received from PSR(to any converter) between\\n * existing converters to save incentive and lower the dependency of users for conversion. So Private Conversion will be executed\\n * by converters on it's own whenever funds are received from PSR. No incentive will be offered during private conversion.\\n *\\n * It will execute on updateAssetsState() function call in Converter Contracts. After this function call, converter will first\\n * check for the amount received. If base asset is received then it will be directly sent to the destination address and no private\\n * conversion will happen otherwise converter will interact with ConverterNetwork contract to find other valid converters who are providing the conversion for:\\n *\\n * tokenAddressIn: As asset received by that converter on updateAssetsState() function call.\\n * tokenAddressOut: As base asset of that converter.\\n *\\n * ConverterNetwork:\\n * This contract will contain all the converters, and will provide valid converters which can perform the execution according to tokenAddressIn\\n * and tokenAddressOut provided.\\n *\\n * findTokenConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for users).\\n *\\n * findTokenConvertersForConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for converters).\\n */\\n\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\nabstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenConverter, ReentrancyGuardUpgradeable {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Maximum incentive could be\\n uint256 public constant MAX_INCENTIVE = 0.5e18;\\n\\n /// @notice Min amount to convert for private conversions. Defined in USD, with 18 decimals\\n uint256 public minAmountToConvert;\\n\\n /// @notice Venus price oracle contract\\n ResilientOracle public priceOracle;\\n\\n /// @notice conversion configurations for the existing pairs\\n /// @dev tokenAddressIn => tokenAddressOut => ConversionConfig\\n mapping(address => mapping(address => ConversionConfig)) public conversionConfigurations;\\n\\n /// @notice Address that all incoming tokens are transferred to\\n address public destinationAddress;\\n\\n /// @notice Boolean for if conversion is paused\\n bool public conversionPaused;\\n\\n /// @notice Address of the converterNetwork contract\\n IConverterNetwork public converterNetwork;\\n\\n /// @dev This empty reserved space is put in place to allow future versions to add new\\n /// variables without shifting down storage in the inheritance chain.\\n /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n uint256[45] private __gap;\\n\\n /// @notice Emitted when config is updated for tokens pair\\n event ConversionConfigUpdated(\\n address indexed tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 oldIncentive,\\n uint256 newIncentive,\\n ConversionAccessibility oldAccess,\\n ConversionAccessibility newAccess\\n );\\n /// @notice Emitted when price oracle address is updated\\n event PriceOracleUpdated(ResilientOracle indexed oldPriceOracle, ResilientOracle indexed priceOracle);\\n\\n /// @notice Emitted when destination address is updated\\n event DestinationAddressUpdated(address indexed oldDestinationAddress, address indexed destinationAddress);\\n\\n /// @notice Emitted when converterNetwork address is updated\\n event ConverterNetworkAddressUpdated(address indexed oldConverterNetwork, address indexed converterNetwork);\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens\\n event ConvertedExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens\\n event ConvertedForExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\\n event ConvertedExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\\n event ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when conversion is paused\\n event ConversionPaused(address indexed sender);\\n\\n /// @notice Emitted when conversion is unpaused\\n event ConversionResumed(address indexed sender);\\n\\n /// @notice Event emitted when tokens are swept\\n event SweepToken(address indexed token, address indexed to, uint256 amount);\\n\\n /// @notice Emitted when minimum amount to convert is updated\\n event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);\\n\\n /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\\n error AmountOutMismatched();\\n\\n /// @notice Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\\n error AmountInMismatched();\\n\\n /// @notice Thrown when given input amount is zero\\n error InsufficientInputAmount();\\n\\n /// @notice Thrown when given output amount is zero\\n error InsufficientOutputAmount();\\n\\n /// @notice Thrown when conversion is disabled or config does not exist for given pair\\n error ConversionConfigNotEnabled();\\n\\n /// @notice Thrown when conversion is enabled only for private conversions\\n error ConversionEnabledOnlyForPrivateConversions();\\n\\n /// @notice Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n error InvalidToAddress();\\n\\n /// @notice Thrown when incentive is higher than the MAX_INCENTIVE\\n error IncentiveTooHigh(uint256 incentive, uint256 maxIncentive);\\n\\n /// @notice Thrown when amountOut is lower than amountOutMin\\n error AmountOutLowerThanMinRequired(uint256 amountOutMantissa, uint256 amountOutMinMantissa);\\n\\n /// @notice Thrown when amountIn is higher than amountInMax\\n error AmountInHigherThanMax(uint256 amountInMantissa, uint256 amountInMaxMantissa);\\n\\n /// @notice Thrown when conversion is paused\\n error ConversionTokensPaused();\\n\\n /// @notice Thrown when conversion is Active\\n error ConversionTokensActive();\\n\\n /// @notice Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\\n error InvalidTokenConfigAddresses();\\n\\n /// @notice Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\\n error InsufficientPoolLiquidity();\\n\\n /// @notice When address of the ConverterNetwork is not set or Zero address\\n error InvalidConverterNetwork();\\n\\n /// @notice Thrown when trying to set non zero incentive for private conversion\\n error NonZeroIncentiveForPrivateConversion();\\n\\n /// @notice Thrown when using convertForExactTokens deflationary tokens\\n error DeflationaryTokenNotSupported();\\n\\n /// @notice Thrown when minimum amount to convert is zero\\n error InvalidMinimumAmountToConvert();\\n\\n /// @notice Thrown when there is a mismatch in the length of input arrays\\n error InputLengthMisMatch();\\n\\n /**\\n * @notice Modifier to ensure valid conversion parameters for a token conversion\\n * and check if conversion is paused or not\\n * @param to The recipient address for the converted tokens\\n * @param tokenAddressIn The input token address for the conversion\\n * @param tokenAddressOut The output token address for the conversion\\n */\\n modifier validConversionParameters(\\n address to,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) {\\n _checkConversionPaused();\\n ensureNonzeroAddress(to);\\n if (to == tokenAddressIn || to == tokenAddressOut) {\\n revert InvalidToAddress();\\n }\\n _;\\n }\\n\\n /// @notice Pause conversion of tokens\\n /// @custom:event Emits ConversionPaused on success\\n /// @custom:error ConversionTokensPaused thrown when conversion is already paused\\n /// @custom:access Restricted by ACM\\n function pauseConversion() external {\\n _checkAccessAllowed(\\\"pauseConversion()\\\");\\n _checkConversionPaused();\\n conversionPaused = true;\\n emit ConversionPaused(msg.sender);\\n }\\n\\n /// @notice Resume conversion of tokens.\\n /// @custom:event Emits ConversionResumed on success\\n /// @custom:error ConversionTokensActive thrown when conversion is already active\\n /// @custom:access Restricted by ACM\\n function resumeConversion() external {\\n _checkAccessAllowed(\\\"resumeConversion()\\\");\\n if (!conversionPaused) {\\n revert ConversionTokensActive();\\n }\\n\\n conversionPaused = false;\\n emit ConversionResumed(msg.sender);\\n }\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:access Only Governance\\n function setPriceOracle(ResilientOracle priceOracle_) external onlyOwner {\\n _setPriceOracle(priceOracle_);\\n }\\n\\n /// @notice Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:access Only Governance\\n function setDestination(address destinationAddress_) external onlyOwner {\\n _setDestination(destinationAddress_);\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:access Only Governance\\n function setConverterNetwork(IConverterNetwork converterNetwork_) external onlyOwner {\\n _setConverterNetwork(converterNetwork_);\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:access Only Governance\\n function setMinAmountToConvert(uint256 minAmountToConvert_) external {\\n _checkAccessAllowed(\\\"setMinAmountToConvert(uint256)\\\");\\n _setMinAmountToConvert(minAmountToConvert_);\\n }\\n\\n /// @notice Batch sets the conversion configurations\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressesOut Array of addresses of tokenOut\\n /// @param conversionConfigs Array of conversionConfig config details to update\\n /// @custom:error InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\\n function setConversionConfigs(\\n address tokenAddressIn,\\n address[] calldata tokenAddressesOut,\\n ConversionConfig[] calldata conversionConfigs\\n ) external {\\n uint256 tokenOutArrayLength = tokenAddressesOut.length;\\n if (tokenOutArrayLength != conversionConfigs.length) revert InputLengthMisMatch();\\n\\n for (uint256 i; i < tokenOutArrayLength; ) {\\n setConversionConfig(tokenAddressIn, tokenAddressesOut[i], conversionConfigs[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n /// @custom:error AmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert AmountInMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract,\\n /// otherwise the amount is adjusted\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n /// @custom:error AmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountOut != amountOutMantissa) {\\n revert AmountOutMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of\\n /// tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted.\\n /// The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokensSupportingFeeOnTransferTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice To sweep ERC20 tokens and transfer them to user(to address)\\n /// @param tokenAddress The address of the ERC-20 token to sweep\\n /// @param to The address to which tokens will be transferred\\n /// @param amount The amount to transfer\\n /// @custom:event Emits SweepToken event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\\n /// @custom:access Only Governance\\n function sweepToken(\\n address tokenAddress,\\n address to,\\n uint256 amount\\n ) external onlyOwner nonReentrant {\\n ensureNonzeroAddress(tokenAddress);\\n ensureNonzeroAddress(to);\\n ensureNonzeroValue(amount);\\n\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n preSweepToken(tokenAddress, amount);\\n token.safeTransfer(to, amount);\\n\\n emit SweepToken(tokenAddress, to, amount);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @notice The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n amountConvertedMantissa = amountInMantissa;\\n uint256 tokenInToOutConversion;\\n (amountOutMantissa, tokenInToOutConversion) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountConvertedMantissa = _divRoundingUp(maxTokenOutReserve * EXP_SCALE, tokenInToOutConversion);\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n\\n amountConvertedMantissa = amountOutMantissa;\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountOutMantissa, ) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountInMantissa;\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountOutMantissa;\\n }\\n\\n /// @notice This method updated the states of this contract after getting funds from PSR\\n /// after settling the amount(if any) through privateConversion between converters\\n /// @dev This function is called by protocolShareReserve\\n /// @dev call _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then\\n /// it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n function updateAssetsState(address comptroller, address asset) public nonReentrant {\\n uint256 balanceDiff = _updateAssetsState(comptroller, asset);\\n if (balanceDiff > 0) {\\n _privateConversion(comptroller, asset, balanceDiff);\\n }\\n }\\n\\n /// @notice Set the configuration for new or existing conversion pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n /// @custom:event Emits ConversionConfigUpdated event on success\\n /// @custom:error Unauthorized error is thrown when the call is not authorized by AccessControlManager\\n /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero\\n /// @custom:error NonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\\n /// @custom:access Controlled by AccessControlManager\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) public {\\n _checkAccessAllowed(\\\"setConversionConfig(address,address,ConversionConfig)\\\");\\n ensureNonzeroAddress(tokenAddressIn);\\n ensureNonzeroAddress(tokenAddressOut);\\n\\n if (conversionConfig.incentive > MAX_INCENTIVE) {\\n revert IncentiveTooHigh(conversionConfig.incentive, MAX_INCENTIVE);\\n }\\n\\n if (\\n (tokenAddressIn == tokenAddressOut) ||\\n (tokenAddressIn != _getDestinationBaseAsset()) ||\\n conversionConfigurations[tokenAddressOut][tokenAddressIn].conversionAccess != ConversionAccessibility.NONE\\n ) {\\n revert InvalidTokenConfigAddresses();\\n }\\n\\n if (\\n (conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) &&\\n conversionConfig.incentive != 0\\n ) {\\n revert NonZeroIncentiveForPrivateConversion();\\n }\\n\\n if (\\n ((conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) ||\\n (conversionConfig.conversionAccess == ConversionAccessibility.ALL)) &&\\n (address(converterNetwork) == address(0))\\n ) {\\n revert InvalidConverterNetwork();\\n }\\n\\n ConversionConfig storage configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n emit ConversionConfigUpdated(\\n tokenAddressIn,\\n tokenAddressOut,\\n configuration.incentive,\\n conversionConfig.incentive,\\n configuration.conversionAccess,\\n conversionConfig.conversionAccess\\n );\\n\\n if (conversionConfig.conversionAccess == ConversionAccessibility.NONE) {\\n delete conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n } else {\\n configuration.incentive = conversionConfig.incentive;\\n configuration.conversionAccess = conversionConfig.conversionAccess;\\n }\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) public view virtual returns (uint256 tokenBalance);\\n\\n /// @dev Operations to perform before sweeping tokens\\n /// @param token Address of the token\\n /// @param amount Amount transferred to address(to)\\n function preSweepToken(address token, uint256 amount) internal virtual {}\\n\\n /// @dev Converts exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return amountOutMantissa Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function _convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 amountOutMantissa) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, amountOutMantissa) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n if (amountOutMantissa < amountOutMinMantissa) {\\n revert AmountOutLowerThanMinRequired(amountOutMantissa, amountOutMinMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for exact amount of tokenAddressOut used for non deflationry tokens\\n /// it is called by convertForExactTokens function\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error DeflationaryTokenNotSupported is thrown if tokenAddressIn is deflationary token\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert DeflationaryTokenNotSupported();\\n }\\n\\n if (actualAmountIn > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n actualAmountOut = amountOutMantissa;\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for the amount of tokenAddressOut used for deflationary tokens\\n /// it is called by convertForExactTokensSupportingFeeOnTransferTokens function\\n /// @notice Advising users to input a smaller amountOutMantissa to avoid potential transaction revert\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n if (amountInMantissa > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, actualAmountOut) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n _doTransferOut(tokenAddressOut, to, actualAmountOut);\\n }\\n\\n /// @dev return actualAmountOut from reserves for tokenAddressOut\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred\\n /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n function _doTransferOut(\\n address tokenAddressOut,\\n address to,\\n uint256 amountConvertedMantissa\\n ) internal {\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountConvertedMantissa) {\\n revert InsufficientPoolLiquidity();\\n }\\n\\n _preTransferHook(tokenAddressOut, amountConvertedMantissa);\\n\\n IERC20Upgradeable tokenOut = IERC20Upgradeable(tokenAddressOut);\\n tokenOut.safeTransfer(to, amountConvertedMantissa);\\n }\\n\\n /// @notice Transfer tokenAddressIn from user to destination\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @return actualAmountIn Actual amount transferred to destination\\n function _doTransferIn(address tokenAddressIn, uint256 amountInMantissa) internal returns (uint256 actualAmountIn) {\\n IERC20Upgradeable tokenIn = IERC20Upgradeable(tokenAddressIn);\\n uint256 balanceBeforeDestination = tokenIn.balanceOf(destinationAddress);\\n tokenIn.safeTransferFrom(msg.sender, destinationAddress, amountInMantissa);\\n uint256 balanceAfterDestination = tokenIn.balanceOf(destinationAddress);\\n actualAmountIn = balanceAfterDestination - balanceBeforeDestination;\\n }\\n\\n /// @dev Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:event Emits PriceOracleUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero\\n function _setPriceOracle(ResilientOracle priceOracle_) internal {\\n ensureNonzeroAddress(address(priceOracle_));\\n emit PriceOracleUpdated(priceOracle, priceOracle_);\\n priceOracle = priceOracle_;\\n }\\n\\n /// @dev Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:event Emits DestinationAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when destination address is zero\\n function _setDestination(address destinationAddress_) internal {\\n ensureNonzeroAddress(destinationAddress_);\\n emit DestinationAddressUpdated(destinationAddress, destinationAddress_);\\n destinationAddress = destinationAddress_;\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:event Emits ConverterNetworkAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n function _setConverterNetwork(IConverterNetwork converterNetwork_) internal {\\n ensureNonzeroAddress(address(converterNetwork_));\\n emit ConverterNetworkAddressUpdated(address(converterNetwork), address(converterNetwork_));\\n converterNetwork = converterNetwork_;\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:event MinAmountToConvertUpdated is emitted in success\\n /// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\n function _setMinAmountToConvert(uint256 minAmountToConvert_) internal {\\n ensureNonzeroValue(minAmountToConvert_);\\n emit MinAmountToConvertUpdated(minAmountToConvert, minAmountToConvert_);\\n minAmountToConvert = minAmountToConvert_;\\n }\\n\\n /// @dev Hook to perform after converting tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param amountIn Amount of tokenIn converted\\n /// @param amountOut Amount of tokenOut converted\\n function _postConversionHook(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n ) internal virtual {}\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n __AccessControlled_init(accessControlManager_);\\n __ReentrancyGuard_init();\\n __AbstractTokenConverter_init_unchained(priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init_unchained(\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n _setPriceOracle(priceOracle_);\\n _setDestination(destinationAddress_);\\n _setMinAmountToConvert(minAmountToConvert_);\\n conversionPaused = false;\\n }\\n\\n /// @dev _updateAssetsState hook to update the states of reserves transferred for the specific comptroller\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n /// @return Amount of asset, for _privateConversion\\n function _updateAssetsState(address comptroller, address asset) internal virtual returns (uint256) {}\\n\\n /// @dev This method is used to convert asset into base asset by converting them with other converters which supports the pair and transfer the funds to\\n /// destination contract as destination's base asset\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset\\n /// @param amountToConvert Amount of the tokenAddressOut transferred to converter\\n function _privateConversion(\\n address comptroller,\\n address tokenAddressOut,\\n uint256 amountToConvert\\n ) internal {\\n address tokenAddressIn = _getDestinationBaseAsset();\\n address _destinationAddress = destinationAddress;\\n uint256 convertedTokenInBalance;\\n if (address(converterNetwork) != address(0)) {\\n (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork\\n .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn);\\n uint256 convertersLength = converterAddresses.length;\\n for (uint256 i; i < convertersLength; ) {\\n if (converterBalances[i] == 0) break;\\n (, uint256 amountIn) = IAbstractTokenConverter(converterAddresses[i]).getUpdatedAmountIn(\\n converterBalances[i],\\n tokenAddressOut,\\n tokenAddressIn\\n );\\n if (amountIn > amountToConvert) {\\n amountIn = amountToConvert;\\n }\\n\\n if (!_validateMinAmountToConvert(amountIn, tokenAddressOut)) {\\n break;\\n }\\n\\n uint256 balanceBefore = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n\\n IERC20Upgradeable(tokenAddressOut).forceApprove(converterAddresses[i], amountIn);\\n IAbstractTokenConverter(converterAddresses[i]).convertExactTokens(\\n amountIn,\\n 0,\\n tokenAddressOut,\\n tokenAddressIn,\\n _destinationAddress\\n );\\n\\n uint256 balanceAfter = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n amountToConvert -= amountIn;\\n convertedTokenInBalance += (balanceAfter - balanceBefore);\\n\\n if (amountToConvert == 0) break;\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n _postPrivateConversionHook(\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance,\\n tokenAddressOut,\\n amountToConvert\\n );\\n }\\n\\n /// @dev This hook is used to update states for the converter after the privateConversion\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressIn Address of the destination's base asset\\n /// @param convertedTokenInBalance Amount of the base asset received after the conversion\\n /// @param tokenAddressOut Address of the asset transferred to other converter in exchange of base asset\\n /// @param convertedTokenOutBalance Amount of tokenAddressOut transferred from this converter\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address tokenAddressOut,\\n uint256 convertedTokenOutBalance\\n ) internal virtual {}\\n\\n /// @notice This hook is used to update the state for asset reserves before transferring tokenOut to user\\n /// @param tokenOutAddress Address of the asset to be transferred to the user\\n /// @param amountOut Amount of tokenAddressOut transferred from this converter\\n function _preTransferHook(address tokenOutAddress, uint256 amountOut) internal virtual {}\\n\\n /// @dev Checks if amount to convert is greater than minimum amount to convert or not\\n /// @param amountIn The amount to convert\\n /// @param tokenAddress Address of the token\\n /// @return isValid true if amount to convert is greater than minimum amount to convert\\n function _validateMinAmountToConvert(uint256 amountIn, address tokenAddress) internal returns (bool isValid) {\\n priceOracle.updateAssetPrice(tokenAddress);\\n uint256 amountInInUsd = (priceOracle.getPrice(tokenAddress) * amountIn) / EXP_SCALE;\\n\\n if (amountInInUsd >= minAmountToConvert) {\\n isValid = true;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountOutMantissa, uint256 tokenInToOutConversion) {\\n if (amountInMantissa == 0) {\\n revert InsufficientInputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n if (address(converterNetwork) != address(0) && (converterNetwork.isTokenConverter(msg.sender))) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n /// amount of tokenAddressOut after including incentive as amountOutMantissa will be greater than actual as it gets\\n /// multiplied by conversionWithIncentive which will be >= 1\\n amountOutMantissa = (amountInMantissa * tokenInToOutConversion) / (EXP_SCALE);\\n }\\n\\n /// @dev To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @dev For user conversions, the function returns an amountInMantissa that is rounded up, ensuring that the equivalent amountInMantissa\\n /// is obtained from users for corresponding amountOutMantissa, preventing any losses to the protocol. However, no rounding up is required for private conversions\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountInMantissa, uint256 tokenInToOutConversion) {\\n if (amountOutMantissa == 0) {\\n revert InsufficientOutputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n\\n bool isPrivateConversion = address(converterNetwork) != address(0) &&\\n converterNetwork.isTokenConverter(msg.sender);\\n if (isPrivateConversion) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n /// amount of tokenAddressIn after considering incentive(i.e. amountInMantissa will be less than actual amountInMantissa if incentive > 0)\\n if (isPrivateConversion) {\\n amountInMantissa =\\n (amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE) /\\n (tokenInUnderlyingPrice * conversionWithIncentive);\\n } else {\\n amountInMantissa = _divRoundingUp(\\n amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE,\\n tokenInUnderlyingPrice * conversionWithIncentive\\n );\\n }\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n }\\n\\n /// @dev Check if msg.sender is allowed to convert as per onlyForPrivateConversions flag\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function _checkPrivateConversion(address tokenAddressIn, address tokenAddressOut) internal view {\\n bool isConverter = (address(converterNetwork) != address(0)) && converterNetwork.isTokenConverter(msg.sender);\\n if (\\n (!(isConverter) &&\\n (conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS))\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n }\\n\\n /// @dev To check, is conversion paused\\n /// @custom:error ConversionTokensPaused is thrown when token conversion is paused\\n function _checkConversionPaused() internal view {\\n if (conversionPaused) {\\n revert ConversionTokensPaused();\\n }\\n }\\n\\n /// @dev Get base asset address of the destination contract\\n /// @return Address of the base asset\\n function _getDestinationBaseAsset() internal view virtual returns (address) {}\\n\\n /// @dev Performs division where the result is rounded up\\n /// @param numerator The numerator of the division operation\\n /// @param denominator The denominator of the division operation. Must be non-zero\\n /// @return The result of the division, rounded up\\n function _divRoundingUp(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\\n return (numerator + denominator - 1) / denominator;\\n }\\n}\\n\",\"keccak256\":\"0xf87680dcb5a46a16663923c575661eda78ef57d29b7d78a85ddac00062426e18\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/IAbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @notice Interface for AbstractTokenConverter\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ninterface IAbstractTokenConverter {\\n /// @notice This enum define the all possible ways of conversion can happen\\n enum ConversionAccessibility {\\n NONE, // Conversion is disable for the pair\\n ALL, // Conversion is enable for private conversion and users\\n ONLY_FOR_CONVERTERS, // Conversion is enable only for private conversion\\n ONLY_FOR_USERS // Conversion is enable only for users\\n }\\n\\n /// @notice This struct represents the configuration for a token conversion.\\n struct ConversionConfig {\\n /// incentive on conversion of tokens in mantissa i.e 10% incentive would be 0.1 * 1e18\\n uint256 incentive;\\n /// enable or disable conversion for users or converters or both or none\\n ConversionAccessibility conversionAccess;\\n }\\n\\n /// @notice Pause conversion of tokens\\n function pauseConversion() external;\\n\\n /// @notice Resume conversion of tokens.\\n function resumeConversion() external;\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n function setPriceOracle(ResilientOracle priceOracle_) external;\\n\\n /// @notice Set the configuration for new or existing convert pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) external;\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Get the configuration for the pair of the tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return incentives Percentage of incentives to be distributed for the pair of tokens\\n /// @return conversionAccess Accessibility for the pair of tokens\\n function conversionConfigurations(address tokenAddressIn, address tokenAddressOut)\\n external\\n returns (uint256 incentives, ConversionAccessibility conversionAccess);\\n\\n /// @notice Get the address of the converterNetwork\\n function converterNetwork() external returns (IConverterNetwork converterNetwork);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) external view returns (uint256 tokenBalance);\\n}\\n\",\"keccak256\":\"0x7852d4f8a6dd1c80d14342f8ff2e26f723eb00c888e9a9e50a5fe8f95c59200c\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/SingleTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\n\\nimport { AbstractTokenConverter } from \\\"./AbstractTokenConverter.sol\\\";\\n\\n/// @title SingleTokenConverter\\n/// @author Venus\\n/// @notice SingleTokenConverter used for token conversions and sends received tokens\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ncontract SingleTokenConverter is AbstractTokenConverter {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Address of the base asset token\\n address public baseAsset;\\n\\n /// @notice Emitted when base asset is updated\\n event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset);\\n\\n /// @notice Emmitted after the funds transferred to the destination address\\n event AssetTransferredToDestination(\\n address indexed receiver,\\n address indexed comptroller,\\n address indexed asset,\\n uint256 amount\\n );\\n\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor() {\\n // Note that the contract is upgradeable. Use initialize() or reinitializers\\n // to set the state variables.\\n _disableInitializers();\\n }\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param baseAsset_ Address of the base asset\\n /// @param minAmountToConvert_ Minimum amount to convert\\n function initialize(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n address baseAsset_,\\n uint256 minAmountToConvert_\\n ) public initializer {\\n _setBaseAsset(baseAsset_);\\n\\n // Initialize AbstractTokenConverter\\n __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @notice Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:access Only Governance\\n function setBaseAsset(address baseAsset_) external onlyOwner {\\n _setBaseAsset(baseAsset_);\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param tokenAddress Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n tokenBalance = token.balanceOf(address(this));\\n }\\n\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address.\\n /// @return balanceLeft Amount of asset, for _privateConversion\\n // solhint-disable-next-line\\n function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) {\\n IERC20Upgradeable token = IERC20Upgradeable(asset);\\n uint256 balance = token.balanceOf(address(this));\\n balanceLeft = balance;\\n\\n if (asset == baseAsset) {\\n balanceLeft = 0;\\n token.safeTransfer(destinationAddress, balance);\\n emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance);\\n }\\n }\\n\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address,\\n uint256\\n ) internal override {\\n if (convertedTokenInBalance > 0) {\\n emit AssetTransferredToDestination(\\n destinationAddress,\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance\\n );\\n }\\n }\\n\\n /// @dev Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n /// @custom:event BaseAssetUpdated is emitted on success\\n function _setBaseAsset(address baseAsset_) internal {\\n ensureNonzeroAddress(baseAsset_);\\n emit BaseAssetUpdated(baseAsset, baseAsset_);\\n baseAsset = baseAsset_;\\n }\\n\\n /// @dev Get base asset address\\n /// @return destinationBaseAsset Address of the base asset(baseAsset)\\n function _getDestinationBaseAsset() internal view override returns (address destinationBaseAsset) {\\n destinationBaseAsset = baseAsset;\\n }\\n}\\n\",\"keccak256\":\"0x907f72b2fe32429d4a0fc95e4daee85e313be2593a0ae5734559f019f66a2b37\",\"license\":\"BSD-3-Clause\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061025c5760003560e01c806379ba509711610145578063ca325469116100bd578063f04c31871161008c578063f2fde38b11610071578063f2fde38b14610533578063f7013ef614610546578063fe3da9841461055957600080fd5b8063f04c31871461050d578063f0dc7e9d1461052057600080fd5b8063ca325469146104c6578063cdf456e1146104d9578063e2ff7ea2146104ed578063e30c3978146104fc57600080fd5b8063b491ddf711610114578063b6828c57116100f9578063b6828c5714610498578063bc368b04146104ab578063c0654646146104b357600080fd5b8063b491ddf714610444578063b4a0bdf31461048757600080fd5b806379ba5097146104055780638da5cb5b1461040d57806390fa7b541461041e578063aac59a751461043157600080fd5b8063530e784f116101d85780636daa463b116101a757806370a082311161018c57806370a08231146103c9578063715018a6146103ea578063746460a9146103f257600080fd5b80636daa463b146103a35780636f1a30a8146103b657600080fd5b8063530e784f1461036257806358b904df146103755780635e1e63251461037d57806364aff9ec1461039057600080fd5b80630e32cb861161022f5780633606b26c116102145780633606b26c14610329578063439727a51461033c57806352e21a181461034f57600080fd5b80630e32cb86146103035780632630c12f1461031657600080fd5b806301e201781461026157806307aa239e146102915780630a0a05e6146102c65780630a9a2b72146102db575b600080fd5b60ff54610274906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b60fe546102b69074010000000000000000000000000000000000000000900460ff1681565b6040519015158152602001610288565b6102d96102d43660046139b6565b610562565b005b6102ee6102e93660046139d3565b610576565b60408051928352602083019190915201610288565b6102d96103113660046139b6565b610624565b60fc54610274906001600160a01b031681565b6102d96103373660046139b6565b610635565b6102ee61034a366004613a15565b610646565b6102d961035d3660046139b6565b610784565b6102d96103703660046139b6565b610795565b6102d96107a6565b6102ee61038b3660046139d3565b61088c565b6102d961039e366004613a74565b61095a565b6102ee6103b13660046139d3565b6109f7565b6102ee6103c43660046139d3565b610b00565b6103dc6103d73660046139b6565b610bff565b604051908152602001610288565b6102d9610c8c565b6102d9610400366004613ab5565b610ca0565b6102d9610ce7565b6033546001600160a01b0316610274565b6102ee61042c366004613a15565b610d77565b6102d961043f366004613ace565b610e61565b610479610452366004613ace565b60fd6020908152600092835260408084209091529082529020805460019091015460ff1682565b604051610288929190613b71565b6097546001600160a01b0316610274565b6102ee6104a6366004613a15565b610e97565b6102d9610f81565b6102d96104c1366004613bd1565b611033565b60fe54610274906001600160a01b031681565b61012d54610274906001600160a01b031681565b6103dc6706f05b59d3b2000081565b6065546001600160a01b0316610274565b6102ee61051b366004613a15565b6110d1565b6102d961052e366004613c85565b6111f4565b6102d96105413660046139b6565b611593565b6102d9610554366004613cf6565b61161c565b6103dc60fb5481565b61056a6117a6565b61057381611800565b50565b60008060026001600160a01b03808616600090815260fd602090815260408083209388168352929052206001015460ff1660038111156105b8576105b8613b07565b036105ef576040517f03410cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006105fa84610bff565b905085811015610608578095505b85925061061686868661187d565b508092505050935093915050565b61062c6117a6565b61057381611be3565b61063d6117a6565b61057381611cd8565b600080828585610654611d57565b61065d83611dac565b816001600160a01b0316836001600160a01b0316148061068e5750806001600160a01b0316836001600160a01b0316145b156106c5576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6106cd611dec565b6106da8a8a8a8a8a611e45565b9095509350898514610718576040517fc214279600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604080516001600160a01b038a81168252602082018890529181018690528189169188169033907f795a235be939acb902ac69562805f86e1341a9b019c351b996e2aa2dfc34c67c906060015b60405180910390a4610777600160c955565b5050509550959350505050565b61078c6117a6565b61057381611ecc565b61079d6117a6565b61057381611f49565b6107e46040518060400160405280601281526020017f726573756d65436f6e76657273696f6e28290000000000000000000000000000815250611fc6565b60fe5474010000000000000000000000000000000000000000900460ff16610837576040517e6d8dbb00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fe80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff16905560405133907f89b79206f08dadd78502cff5075d2b094fa0abea0b063cfafe4475e2a380c51f90600090a2565b60008060026001600160a01b03808616600090815260fd602090815260408083209388168352929052206001015460ff1660038111156108ce576108ce613b07565b03610905576040517f03410cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8491506000610915868686612092565b9092509050600061092585610bff565b9050828110156109505761094a610944670de0b6b3a764000083613d89565b8361239f565b93508092505b5050935093915050565b6109626117a6565b61096a611dec565b61097383611dac565b61097c82611dac565b610985816123cb565b8261099a6001600160a01b0382168484612405565b826001600160a01b0316846001600160a01b03167f6d25be279134f4ecaa4770aff0c3d916d9e7c5ef37b65ed95dbdba411f5d54d5846040516109df91815260200190565b60405180910390a3506109f2600160c955565b505050565b60fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038481166004830152600092839291169063b62cad6990602401600060405180830381600087803b158015610a5b57600080fd5b505af1158015610a6f573d6000803e3d6000fd5b505060fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038781166004830152909116925063b62cad699150602401600060405180830381600087803b158015610ad357600080fd5b505af1158015610ae7573d6000803e3d6000fd5b50505050610af6858585612092565b5094959350505050565b60fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038481166004830152600092839291169063b62cad6990602401600060405180830381600087803b158015610b6457600080fd5b505af1158015610b78573d6000803e3d6000fd5b505060fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038781166004830152909116925063b62cad699150602401600060405180830381600087803b158015610bdc57600080fd5b505af1158015610bf0573d6000803e3d6000fd5b50505050610af685858561187d565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015260009082906001600160a01b038216906370a0823190602401602060405180830381865afa158015610c61573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c859190613da0565b9392505050565b610c946117a6565b610c9e60006124cc565b565b610cde6040518060400160405280601e81526020017f7365744d696e416d6f756e74546f436f6e766572742875696e74323536290000815250611fc6565b610573816124fd565b60655433906001600160a01b03168114610d6e5760405162461bcd60e51b815260206004820152602960248201527f4f776e61626c6532537465703a2063616c6c6572206973206e6f74207468652060448201527f6e6577206f776e6572000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b610573816124cc565b600080828585610d85611d57565b610d8e83611dac565b816001600160a01b0316836001600160a01b03161480610dbf5750806001600160a01b0316836001600160a01b0316145b15610df6576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610dfe611dec565b610e0b8a8a8a8a8a611e45565b9095509350604080516001600160a01b038a81168252602082018890529181018690528189169188169033907f93b7ba2a2b0e36320375853d7466af5685c07567804b871b4fdfd31e3bb7715490606001610765565b610e69611dec565b6000610e758383612547565b90508015610e8857610e8883838361265c565b50610e93600160c955565b5050565b600080828585610ea5611d57565b610eae83611dac565b816001600160a01b0316836001600160a01b03161480610edf5750806001600160a01b0316836001600160a01b0316145b15610f16576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610f1e611dec565b610f2b8a8a8a8a8a612ab9565b9095509350604080516001600160a01b038a81168252602082018890529181018690528189169188169033907f9b7dc1d7d2974d015b4fc39889a09f3a3923add808f5863158f3162d997d4e8290606001610765565b610fbf6040518060400160405280601181526020017f7061757365436f6e76657273696f6e2829000000000000000000000000000000815250611fc6565b610fc7611d57565b60fe80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000017905560405133907f490bc639fd0d96f19c8adf77bc98d17fbefdee2e1e1864d21f041360d0ee065a90600090a2565b8281811461106d576040517f4d5590f300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60005b818110156110c8576110c08787878481811061108e5761108e613db9565b90506020020160208101906110a391906139b6565b8686858181106110b5576110b5613db9565b9050604002016111f4565b600101611070565b50505050505050565b6000808285856110df611d57565b6110e883611dac565b816001600160a01b0316836001600160a01b031614806111195750806001600160a01b0316836001600160a01b0316145b15611150576040517f8aa3a72f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b611158611dec565b6111658a8a8a8a8a612b4b565b90955093508884146111a3576040517fa8dc653c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604080516001600160a01b038a81168252602082018890529181018690528189169188169033907fcb4ea7de8d069b0f443b792cba6c6df5096508951bbc75c04ac42c9251efe07690606001610765565b61121560405180606001604052806035815260200161419a60359139611fc6565b61121e83611dac565b61122782611dac565b6706f05b59d3b200008135111561127b576040517f9770caee000000000000000000000000000000000000000000000000000000008152813560048201526706f05b59d3b200006024820152604401610d65565b816001600160a01b0316836001600160a01b031614806112aa575061012d546001600160a01b03848116911614155b806112f2575060006001600160a01b03808416600090815260fd602090815260408083209388168352929052206001015460ff1660038111156112ef576112ef613b07565b14155b15611329576040517feebb5ac600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600261133b6040830160208401613de8565b600381111561134c5761134c613b07565b1480156113595750803515155b15611390576040517fd0d4aabe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60026113a26040830160208401613de8565b60038111156113b3576113b3613b07565b14806113df575060016113cc6040830160208401613de8565b60038111156113dd576113dd613b07565b145b80156113f4575060ff546001600160a01b0316155b1561142b576040517fe7c2c99400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b03808416600081815260fd602090815260408083209487168084529482529182902080546001820154919594937f39fbfdd5da133303ed31b1b65e30a0ddf7a9236573368c66c859dceccc1dd12a93919288359260ff9091169161149b91908a01908a01613de8565b6040516114ab9493929190613e09565b60405180910390a360006114c56040840160208501613de8565b60038111156114d6576114d6613b07565b03611533576001600160a01b03808516600090815260fd60209081526040808320938716835292905290812090815560010180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016905561158d565b813581556115476040830160208401613de8565b6001808301805490917fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff009091169083600381111561158757611587613b07565b02179055505b50505050565b61159b6117a6565b606580546001600160a01b0383167fffffffffffffffffffffffff000000000000000000000000000000000000000090911681179091556115e46033546001600160a01b031690565b6001600160a01b03167f38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e2270060405160405180910390a350565b600054610100900460ff161580801561163c5750600054600160ff909116105b806116565750303b158015611656575060005460ff166001145b6116c85760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a65640000000000000000000000000000000000006064820152608401610d65565b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055801561172657600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b61172f83611cd8565b61173b86868685612c08565b801561179e57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b505050505050565b6033546001600160a01b03163314610c9e5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610d65565b61180981611dac565b60fe546040516001600160a01b038084169216907f9be3097b5c8b276786be52a244ee90d66efd34805d9eb16f168fb2b4aaae9a2b90600090a360fe80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b600080846000036118ba576040517f42301c2300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b03808516600090815260fd6020908152604080832093871683529281528282208351808501909452805484526001810154929392909183019060ff16600381111561190e5761190e613b07565b600381111561191f5761191f613b07565b905250905060008160200151600381111561193c5761193c613b07565b03611973576040517f618ce59700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483015260009216906341976e0990602401602060405180830381865afa1580156119d7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906119fb9190613da0565b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b038881166004830152929350600092909116906341976e0990602401602060405180830381865afa158015611a64573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611a889190613da0565b835160ff54919250906000906001600160a01b031615801590611b2b575060ff546040517f6c059fb10000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b0390911690636c059fb190602401602060405180830381865afa158015611b07573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b2b9190613e31565b90508015611b3857600091505b6000611b4c83670de0b6b3a7640000613e53565b90508115611b8c57611b5e8186613d89565b670de0b6b3a7640000611b71868e613d89565b611b7b9190613d89565b611b859190613e66565b9750611bbe565b611bbb670de0b6b3a7640000611ba2868e613d89565b611bac9190613d89565b611bb68388613d89565b61239f565b97505b83611bc98287613d89565b611bd39190613e66565b9650505050505050935093915050565b6001600160a01b038116611c5f5760405162461bcd60e51b815260206004820152602560248201527f696e76616c696420616365737320636f6e74726f6c206d616e6167657220616460448201527f64726573730000000000000000000000000000000000000000000000000000006064820152608401610d65565b609780546001600160a01b038381167fffffffffffffffffffffffff000000000000000000000000000000000000000083168117909355604080519190921680825260208201939093527f66fd58e82f7b31a2a5c30e0888f3093efe4e111b00cd2b0c31fe014601293aa0910160405180910390a15050565b611ce181611dac565b61012d546040516001600160a01b038084169216907f4fe44995ca2482562846e3c0413d9bd6147e9ce1881c66a8765e8542fef99f4290600090a361012d80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b60fe5474010000000000000000000000000000000000000000900460ff1615610c9e576040517f952bcf7f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b038116610573576040517f8579befe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600260c95403611e3e5760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610d65565b600260c955565b600080611e528585612ca1565b611e5c8588612dc1565b9150611e698286866109f7565b91505085811015611eb0576040517f228f8c110000000000000000000000000000000000000000000000000000000081526004810182905260248101879052604401610d65565b611ebb848483612f0c565b9550959350505050565b600160c955565b611ed581611dac565b60ff546040516001600160a01b038084169216907f50f1a16bf24734355b14ff800d132cc0a934808b8621d5623b41bc67f204881790600090a360ff80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b611f5281611dac565b60fc546040516001600160a01b038084169216907f56b5f80d8cac1479698aa7d01605fd6111e90b15fc4d2b377417f46034876cbd90600090a360fc80547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0392909216919091179055565b6097546040517f18c5e8ab0000000000000000000000000000000000000000000000000000000081526000916001600160a01b0316906318c5e8ab906120129033908690600401613f0f565b602060405180830381865afa15801561202f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906120539190613e31565b905080610e93573330836040517f4a3fa293000000000000000000000000000000000000000000000000000000008152600401610d6593929190613f31565b600080846000036120cf576040517f098fb56100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b03808516600090815260fd6020908152604080832093871683529281528282208351808501909452805484526001810154929392909183019060ff16600381111561212357612123613b07565b600381111561213457612134613b07565b905250905060008160200151600381111561215157612151613b07565b03612188576040517f618ce59700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483015260009216906341976e0990602401602060405180830381865afa1580156121ec573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906122109190613da0565b60fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b038881166004830152929350600092909116906341976e0990602401602060405180830381865afa158015612279573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061229d9190613da0565b835160ff54919250906001600160a01b03161580159061233d575060ff546040517f6c059fb10000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b0390911690636c059fb190602401602060405180830381865afa158015612319573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061233d9190613e31565b15612346575060005b600061235a82670de0b6b3a7640000613e53565b9050826123678286613d89565b6123719190613e66565b9550670de0b6b3a7640000612386878c613d89565b6123909190613e66565b96505050505050935093915050565b60008160016123ae8286613e53565b6123b89190613f5d565b6123c29190613e66565b90505b92915050565b80600003610573576040517f9cf8540c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040516001600160a01b0383166024820152604481018290526109f29084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064015b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090931692909217909152612f6f565b606580547fffffffffffffffffffffffff000000000000000000000000000000000000000016905561057381613057565b612506816123cb565b60fb5460408051918252602082018390527fada67d0d38fa20c8ae6a5c17cb9d60b0fe7f2d4e4f27ac9ee55e54ac88de9d8d910160405180910390a160fb55565b6040517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152600090829082906001600160a01b038316906370a0823190602401602060405180830381865afa1580156125ab573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906125cf9190613da0565b61012d549093508391506001600160a01b03908116908516036126545760fe546000935061260a906001600160a01b03848116911683612405565b60fe546040518281526001600160a01b0386811692888216929116907fadc20ad416881f76b4304665c35f5be8592297bcdfe4f0bb087b9d254222af559060200160405180910390a45b505092915050565b600061267161012d546001600160a01b031690565b60fe5460ff549192506001600160a01b03908116916000911615612aac5760ff546040517f4e9f8f390000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483015285811660248301526000928392911690634e9f8f39906044016000604051808303816000875af1158015612700573d6000803e3d6000fd5b505050506040513d6000823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01682016040526127469190810190614081565b8151919350915060005b81811015612aa75782818151811061276a5761276a613db9565b602002602001015160000315612aa757600084828151811061278e5761278e613db9565b60200260200101516001600160a01b0316636f1a30a88584815181106127b6576127b6613db9565b60200260200101518c8b6040518463ffffffff1660e01b81526004016127f8939291909283526001600160a01b03918216602084015216604082015260600190565b60408051808303816000875af1158015612816573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061283a9190614146565b915050888111156128485750875b612852818b6130c1565b61285c5750612aa7565b6040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b038881166004830152600091908a16906370a0823190602401602060405180830381865afa1580156128bf573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906128e39190613da0565b905061291c8684815181106128fa576128fa613db9565b6020026020010151838d6001600160a01b03166131f99092919063ffffffff16565b85838151811061292e5761292e613db9565b60209081029190910101516040517f439727a500000000000000000000000000000000000000000000000000000000815260048101849052600060248201526001600160a01b038d811660448301528b811660648301528a811660848301529091169063439727a59060a40160408051808303816000875af11580156129b8573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129dc9190614146565b50506040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b038981166004830152600091908b16906370a0823190602401602060405180830381865afa158015612a41573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612a659190613da0565b9050612a71838c613f5d565b9a50612a7d8282613f5d565b612a879089613e53565b97508a600003612a9957505050612aa7565b836001019350505050612750565b505050505b61179e86848388886132cf565b600080612ac68585612ca1565b6000612ad3878787610b00565b91505087811115612b1a576040517f71b5f0c10000000000000000000000000000000000000000000000000000000081526004810182905260248101899052604401610d65565b612b248682612dc1565b9250612b318387876109f7565b9250612b409050858584612f0c565b509550959350505050565b600080612b588585612ca1565b6000612b65878787610b00565b915050612b728682612dc1565b9250808314612bad576040517f0c5c1c2000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b87831115612bf1576040517f71b5f0c10000000000000000000000000000000000000000000000000000000081526004810182905260248101899052604401610d65565b612bfc858589612f0c565b50909694955050505050565b600054610100900460ff16612c855760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b612c8e84613325565b612c966133b3565b61158d838383613438565b60ff546000906001600160a01b031615801590612d3e575060ff546040517f6c059fb10000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b0390911690636c059fb190602401602060405180830381865afa158015612d1a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612d3e9190613e31565b905080158015612d8a575060026001600160a01b03808516600090815260fd602090815260408083209387168352929052206001015460ff166003811115612d8857612d88613b07565b145b156109f2576040517f03410cd100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60fe546040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b039182166004820152600091849183918316906370a0823190602401602060405180830381865afa158015612e2a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612e4e9190613da0565b60fe54909150612e6d906001600160a01b0384811691339116876134fd565b60fe546040517f70a082310000000000000000000000000000000000000000000000000000000081526001600160a01b0391821660048201526000918416906370a0823190602401602060405180830381865afa158015612ed2573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612ef69190613da0565b9050612f028282613f5d565b9695505050505050565b6000612f1784610bff565b905081811015612f53576040517f6bb2792900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b83612f686001600160a01b0382168585612405565b5050505050565b6000612fc4826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b031661354e9092919063ffffffff16565b9050805160001480612fe5575080806020019051810190612fe59190613e31565b6109f25760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610d65565b603380546001600160a01b038381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60fc546040517fb62cad690000000000000000000000000000000000000000000000000000000081526001600160a01b038381166004830152600092169063b62cad6990602401600060405180830381600087803b15801561312257600080fd5b505af1158015613136573d6000803e3d6000fd5b505060fc546040517f41976e090000000000000000000000000000000000000000000000000000000081526001600160a01b03868116600483015260009450670de0b6b3a76400009350879216906341976e0990602401602060405180830381865afa1580156131aa573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906131ce9190613da0565b6131d89190613d89565b6131e29190613e66565b905060fb5481106131f257600191505b5092915050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f095ea7b3000000000000000000000000000000000000000000000000000000001790526132788482613565565b61158d576040516001600160a01b0384166024820152600060448201526132c59085907f095ea7b3000000000000000000000000000000000000000000000000000000009060640161244a565b61158d8482612f6f565b8215612f685760fe546040518481526001600160a01b0386811692888216929116907fadc20ad416881f76b4304665c35f5be8592297bcdfe4f0bb087b9d254222af559060200160405180910390a45050505050565b600054610100900460ff166133a25760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b6133aa61360c565b61057381613691565b600054610100900460ff166134305760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b610c9e61370e565b600054610100900460ff166134b55760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b6134be83611f49565b6134c782611800565b6134d0816124fd565b505060fe80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff16905550565b6040516001600160a01b038085166024830152831660448201526064810182905261158d9085907f23b872dd000000000000000000000000000000000000000000000000000000009060840161244a565b606061355d848460008561378b565b949350505050565b6000806000846001600160a01b031684604051613582919061416a565b6000604051808303816000865af19150503d80600081146135bf576040519150601f19603f3d011682016040523d82523d6000602084013e6135c4565b606091505b50915091508180156135ee5750805115806135ee5750808060200190518101906135ee9190613e31565b801561360357506001600160a01b0385163b15155b95945050505050565b600054610100900460ff166136895760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b610c9e61387d565b600054610100900460ff1661062c5760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b600054610100900460ff16611ec55760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b6060824710156138035760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610d65565b600080866001600160a01b0316858760405161381f919061416a565b60006040518083038185875af1925050503d806000811461385c576040519150601f19603f3d011682016040523d82523d6000602084013e613861565b606091505b509150915061387287838387613903565b979650505050505050565b600054610100900460ff166138fa5760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610d65565b610c9e336124cc565b6060831561397257825160000361396b576001600160a01b0385163b61396b5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610d65565b508161355d565b61355d83838151156139875781518083602001fd5b8060405162461bcd60e51b8152600401610d659190614186565b6001600160a01b038116811461057357600080fd5b6000602082840312156139c857600080fd5b8135610c85816139a1565b6000806000606084860312156139e857600080fd5b8335925060208401356139fa816139a1565b91506040840135613a0a816139a1565b809150509250925092565b600080600080600060a08688031215613a2d57600080fd5b85359450602086013593506040860135613a46816139a1565b92506060860135613a56816139a1565b91506080860135613a66816139a1565b809150509295509295909350565b600080600060608486031215613a8957600080fd5b8335613a94816139a1565b92506020840135613aa4816139a1565b929592945050506040919091013590565b600060208284031215613ac757600080fd5b5035919050565b60008060408385031215613ae157600080fd5b8235613aec816139a1565b91506020830135613afc816139a1565b809150509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b60048110613b6d577f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b9052565b82815260408101610c856020830184613b36565b60008083601f840112613b9757600080fd5b50813567ffffffffffffffff811115613baf57600080fd5b6020830191508360208260061b8501011115613bca57600080fd5b9250929050565b600080600080600060608688031215613be957600080fd5b8535613bf4816139a1565b9450602086013567ffffffffffffffff80821115613c1157600080fd5b818801915088601f830112613c2557600080fd5b813581811115613c3457600080fd5b8960208260051b8501011115613c4957600080fd5b602083019650809550506040880135915080821115613c6757600080fd5b50613c7488828901613b85565b969995985093965092949392505050565b60008060008385036080811215613c9b57600080fd5b8435613ca6816139a1565b93506020850135613cb6816139a1565b925060407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc082011215613ce857600080fd5b506040840190509250925092565b600080600080600060a08688031215613d0e57600080fd5b8535613d19816139a1565b94506020860135613d29816139a1565b93506040860135613d39816139a1565b92506060860135613d49816139a1565b949793965091946080013592915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b80820281158282048414176123c5576123c5613d5a565b600060208284031215613db257600080fd5b5051919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600060208284031215613dfa57600080fd5b813560048110610c8557600080fd5b8481526020810184905260808101613e246040830185613b36565b6136036060830184613b36565b600060208284031215613e4357600080fd5b81518015158114610c8557600080fd5b808201808211156123c5576123c5613d5a565b600082613e9c577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b60005b83811015613ebc578181015183820152602001613ea4565b50506000910152565b60008151808452613edd816020860160208601613ea1565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b6001600160a01b038316815260406020820152600061355d6040830184613ec5565b60006001600160a01b038086168352808516602084015250606060408301526136036060830184613ec5565b818103818111156123c5576123c5613d5a565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff81118282101715613fe657613fe6613f70565b604052919050565b600067ffffffffffffffff82111561400857614008613f70565b5060051b60200190565b600082601f83011261402357600080fd5b8151602061403861403383613fee565b613f9f565b8083825260208201915060208460051b87010193508684111561405a57600080fd5b602086015b84811015614076578051835291830191830161405f565b509695505050505050565b6000806040838503121561409457600080fd5b825167ffffffffffffffff808211156140ac57600080fd5b818501915085601f8301126140c057600080fd5b815160206140d061403383613fee565b82815260059290921b840181019181810190898411156140ef57600080fd5b948201945b83861015614116578551614107816139a1565b825294820194908201906140f4565b9188015191965090935050508082111561412f57600080fd5b5061413c85828601614012565b9150509250929050565b6000806040838503121561415957600080fd5b505080516020909101519092909150565b6000825161417c818460208701613ea1565b9190910192915050565b6020815260006123c26020830184613ec556fe736574436f6e76657273696f6e436f6e66696728616464726573732c616464726573732c436f6e76657273696f6e436f6e66696729a2646970667358221220344f76b4d0000b9523eecb9df4a64afba3e71c8b4fe0560c93ff5d115f78deb364736f6c63430008190033", + "numDeployments": 5, + "solcInputHash": "dceb6d0de70f90933a7f2cdf26a987ca", + "metadata": "{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountInHigherThanMax\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountInMismatched\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"}],\"name\":\"AmountOutLowerThanMinRequired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountOutMismatched\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionConfigNotEnabled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionEnabledOnlyForPrivateConversions\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensActive\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConversionTokensPaused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DeflationaryTokenNotSupported\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DirectTransferBaseAssetNotAllowed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxIncentive\",\"type\":\"uint256\"}],\"name\":\"IncentiveTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InputLengthMisMatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientInputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientOutputAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientPoolLiquidity\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidConverterNetwork\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidMinimumAmountToConvert\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidToAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokenConfigAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NonZeroIncentiveForPrivateConversion\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"SameAssetDirectTransferNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SameBaseAssetNotAllowed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"calledContract\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"methodSignature\",\"type\":\"string\"}],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddressNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroValueNotAllowed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"AssetTransferredToDestination\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"AssetsDirectTransferUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldBaseAsset\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newBaseAsset\",\"type\":\"address\"}],\"name\":\"BaseAssetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newIncentive\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"oldAccess\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"newAccess\",\"type\":\"uint8\"}],\"name\":\"ConversionConfigUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ConversionResumed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"ConvertedForExactTokensSupportingFeeOnTransferTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldConverterNetwork\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"converterNetwork\",\"type\":\"address\"}],\"name\":\"ConverterNetworkAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldDestinationAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"}],\"name\":\"DestinationAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldMinAmountToConvert\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newMinAmountToConvert\",\"type\":\"uint256\"}],\"name\":\"MinAmountToConvertUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldAccessControlManager\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAccessControlManager\",\"type\":\"address\"}],\"name\":\"NewAccessControlManager\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"oldPriceOracle\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle\",\"type\":\"address\"}],\"name\":\"PriceOracleUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SweepToken\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MAX_INCENTIVE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"accessControlManager\",\"outputs\":[{\"internalType\":\"contract IAccessControlManagerV8\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"assetsDirectTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"baseAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"conversionConfigurations\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"conversionPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMinMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMaxMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"convertForExactTokensSupportingFeeOnTransferTokens\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"actualAmountIn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"actualAmountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"converterNetwork\",\"outputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"destinationAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountIn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountInMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"}],\"name\":\"getUpdatedAmountOut\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountConvertedMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMantissa\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"},{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minAmountToConvert\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"priceOracle\",\"outputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeConversion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"accessControlManager_\",\"type\":\"address\"}],\"name\":\"setAccessControlManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"assets\",\"type\":\"address[]\"},{\"internalType\":\"bool[]\",\"name\":\"values\",\"type\":\"bool[]\"}],\"name\":\"setAssetsDirectTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"baseAsset_\",\"type\":\"address\"}],\"name\":\"setBaseAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddressOut\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig\",\"name\":\"conversionConfig\",\"type\":\"tuple\"}],\"name\":\"setConversionConfig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddressIn\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"tokenAddressesOut\",\"type\":\"address[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"incentive\",\"type\":\"uint256\"},{\"internalType\":\"enum IAbstractTokenConverter.ConversionAccessibility\",\"name\":\"conversionAccess\",\"type\":\"uint8\"}],\"internalType\":\"struct IAbstractTokenConverter.ConversionConfig[]\",\"name\":\"conversionConfigs\",\"type\":\"tuple[]\"}],\"name\":\"setConversionConfigs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IConverterNetwork\",\"name\":\"converterNetwork_\",\"type\":\"address\"}],\"name\":\"setConverterNetwork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destinationAddress_\",\"type\":\"address\"}],\"name\":\"setDestination\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountToConvert_\",\"type\":\"uint256\"}],\"name\":\"setMinAmountToConvert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract ResilientOracle\",\"name\":\"priceOracle_\",\"type\":\"address\"}],\"name\":\"setPriceOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sweepToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"comptroller\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"updateAssetsState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Venus\",\"custom:security-contact\":\"https://github.com/VenusProtocol/protocol-reserve#discussion\",\"errors\":{\"SameAssetDirectTransferNotAllowed(address,bool)\":[{\"params\":{\"asset\":\"The asset address whose `assetDirectTransfer` value went to be set\",\"value\":\"The value to be set\"}}]},\"events\":{\"Initialized(uint8)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"}},\"kind\":\"dev\",\"methods\":{\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"balanceOf(address)\":{\"params\":{\"tokenAddress\":\"Address of the token\"},\"returns\":{\"tokenBalance\":\"Balance of the token the contract has\"}},\"constructor\":{\"custom:oz-upgrades-unsafe-allow\":\"constructor\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissaAmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\",\"custom:event\":\"Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"amountOutMinMantissa\":\"Min amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissaAmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\",\"custom:event\":\"Emits ConvertedForExactTokens event on success\",\"details\":\"Method does not support deflationary tokens transfer\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"custom:error\":\"ZeroAddressNotAllowed is thrown when to address is zeroInvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOutAmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\",\"custom:event\":\"Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\",\"params\":{\"amountInMaxMantissa\":\"Max amount of tokenAddressIn\",\"amountOutMantissa\":\"Amount of tokenAddressOut required as output\",\"to\":\"Address of the tokenAddressOut receiver\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"actualAmountIn\":\"Actual amount transferred to destination\",\"actualAmountOut\":\"Actual amount transferred to user\"}},\"getAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pairConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\",\"details\":\"This function retrieves values without altering token prices\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"getUpdatedAmountIn(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountOutMantissa\":\"Amount of tokenAddressOut user wants to receive\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressOut should be transferred after conversion\",\"amountInMantissa\":\"Amount of the tokenAddressIn sender would send to contract before conversion\"}},\"getUpdatedAmountOut(uint256,address,address)\":{\"custom:error\":\"InsufficientInputAmount error is thrown when given input amount is zeroConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\",\"params\":{\"amountInMantissa\":\"Amount of tokenAddressIn\",\"tokenAddressIn\":\"Address of the token to convert\",\"tokenAddressOut\":\"Address of the token to get after conversion\"},\"returns\":{\"amountConvertedMantissa\":\"Amount of tokenAddressIn should be transferred after conversion\",\"amountOutMantissa\":\"Amount of the tokenAddressOut sender should receive after conversion\"}},\"initialize(address,address,address,address,uint256)\":{\"params\":{\"accessControlManager_\":\"Access control manager contract address\",\"baseAsset_\":\"Address of the base asset\",\"destinationAddress_\":\"Address at all incoming tokens will transferred to\",\"minAmountToConvert_\":\"Minimum amount to convert\",\"priceOracle_\":\"Resilient oracle address\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pauseConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensPaused thrown when conversion is already paused\",\"custom:event\":\"Emits ConversionPaused on success\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"resumeConversion()\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"ConversionTokensActive thrown when conversion is already active\",\"custom:event\":\"Emits ConversionResumed on success\"},\"setAccessControlManager(address)\":{\"custom:access\":\"Only Governance\",\"custom:event\":\"Emits NewAccessControlManager event\",\"details\":\"Admin function to set address of AccessControlManager\",\"params\":{\"accessControlManager_\":\"The new address of the AccessControlManager\"}},\"setAssetsDirectTransfer(address[],bool[])\":{\"custom:access\":\"Restricted by ACM\",\"custom:error\":\"InputLengthMisMatch thrown when assets and values array lengths don't match\",\"custom:event\":\"AssetsDirectTransferUpdated emits on success\",\"params\":{\"assets\":\"Addresses of the assets need to be added or removed for direct transfer\",\"values\":\"Boolean value to indicate whether direct transfer is allowed for each asset.\"}},\"setBaseAsset(address)\":{\"custom:access\":\"Only Governance\",\"custom:error\":\"ZeroAddressNotAllowed is thrown when address is zeroSameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\",\"custom:event\":\"BaseAssetUpdated is emitted on success\",\"params\":{\"baseAsset_\":\"The new address of the base asset\"}},\"setConversionConfig(address,address,(uint256,uint8))\":{\"custom:access\":\"Controlled by AccessControlManager\",\"custom:error\":\"Unauthorized error is thrown when the call is not authorized by AccessControlManagerZeroAddressNotAllowed is thrown when pool registry address is zeroNonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\",\"custom:event\":\"Emits ConversionConfigUpdated event on success\",\"params\":{\"conversionConfig\":\"ConversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressOut\":\"Address of tokenOut\"}},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"custom:error\":\"InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\",\"params\":{\"conversionConfigs\":\"Array of conversionConfig config details to update\",\"tokenAddressIn\":\"Address of tokenIn\",\"tokenAddressesOut\":\"Array of addresses of tokenOut\"}},\"setConverterNetwork(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"converterNetwork_\":\"The converterNetwork address to be set\"}},\"setDestination(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"destinationAddress_\":\"The new destination address to be set\"}},\"setMinAmountToConvert(uint256)\":{\"custom:access\":\"Only Governance\",\"params\":{\"minAmountToConvert_\":\"Min amount to convert\"}},\"setPriceOracle(address)\":{\"custom:access\":\"Only Governance\",\"params\":{\"priceOracle_\":\"Address of the new price oracle to set\"}},\"sweepToken(address,address,uint256)\":{\"custom:access\":\"Only Governance\",\"custom:error\":\"ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\",\"custom:event\":\"Emits SweepToken event on success\",\"params\":{\"amount\":\"The amount to transfer\",\"to\":\"The address to which tokens will be transferred\",\"tokenAddress\":\"The address of the ERC-20 token to sweep\"}},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner.\"},\"updateAssetsState(address,address)\":{\"details\":\"This function is called by protocolShareReservecall _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\",\"params\":{\"asset\":\"Asset address\",\"comptroller\":\"Comptroller address (pool)\"}}},\"stateVariables\":{\"assetsDirectTransfer\":{\"details\":\"Asset -> bool(should transfer directly on true)\"}},\"title\":\"SingleTokenConverter\",\"version\":1},\"userdoc\":{\"errors\":{\"AmountInHigherThanMax(uint256,uint256)\":[{\"notice\":\"Thrown when amountIn is higher than amountInMax\"}],\"AmountInMismatched()\":[{\"notice\":\"Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\"}],\"AmountOutLowerThanMinRequired(uint256,uint256)\":[{\"notice\":\"Thrown when amountOut is lower than amountOutMin\"}],\"AmountOutMismatched()\":[{\"notice\":\"Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\"}],\"ConversionConfigNotEnabled()\":[{\"notice\":\"Thrown when conversion is disabled or config does not exist for given pair\"}],\"ConversionEnabledOnlyForPrivateConversions()\":[{\"notice\":\"Thrown when conversion is enabled only for private conversions\"}],\"ConversionTokensActive()\":[{\"notice\":\"Thrown when conversion is Active\"}],\"ConversionTokensPaused()\":[{\"notice\":\"Thrown when conversion is paused\"}],\"DeflationaryTokenNotSupported()\":[{\"notice\":\"Thrown when using convertForExactTokens deflationary tokens\"}],\"DirectTransferBaseAssetNotAllowed()\":[{\"notice\":\"Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection\"}],\"IncentiveTooHigh(uint256,uint256)\":[{\"notice\":\"Thrown when incentive is higher than the MAX_INCENTIVE\"}],\"InputLengthMisMatch()\":[{\"notice\":\"Thrown when there is a mismatch in the length of input arrays\"}],\"InsufficientInputAmount()\":[{\"notice\":\"Thrown when given input amount is zero\"}],\"InsufficientOutputAmount()\":[{\"notice\":\"Thrown when given output amount is zero\"}],\"InsufficientPoolLiquidity()\":[{\"notice\":\"Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\"}],\"InvalidConverterNetwork()\":[{\"notice\":\"When address of the ConverterNetwork is not set or Zero address\"}],\"InvalidMinimumAmountToConvert()\":[{\"notice\":\"Thrown when minimum amount to convert is zero\"}],\"InvalidToAddress()\":[{\"notice\":\"Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\"}],\"InvalidTokenConfigAddresses()\":[{\"notice\":\"Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\"}],\"NonZeroIncentiveForPrivateConversion()\":[{\"notice\":\"Thrown when trying to set non zero incentive for private conversion\"}],\"SameAssetDirectTransferNotAllowed(address,bool)\":[{\"notice\":\"Thrown when the `assetsDirectTransfer[asset]` is already `value`\"}],\"SameBaseAssetNotAllowed()\":[{\"notice\":\"Thrown when the base asset is the same as the new base asset\"}],\"Unauthorized(address,address,string)\":[{\"notice\":\"Thrown when the action is prohibited by AccessControlManager\"}],\"ZeroAddressNotAllowed()\":[{\"notice\":\"Thrown if the supplied address is a zero address where it is not allowed\"}],\"ZeroValueNotAllowed()\":[{\"notice\":\"Thrown if the supplied value is 0 where it is not allowed\"}]},\"events\":{\"AssetTransferredToDestination(address,address,address,uint256)\":{\"notice\":\"Emmitted after the funds transferred to the destination address\"},\"AssetsDirectTransferUpdated(address,address,bool)\":{\"notice\":\"Emitted after the assetsDirectTransfer mapping is updated\"},\"BaseAssetUpdated(address,address)\":{\"notice\":\"Emitted when base asset is updated\"},\"ConversionConfigUpdated(address,address,uint256,uint256,uint8,uint8)\":{\"notice\":\"Emitted when config is updated for tokens pair\"},\"ConversionPaused(address)\":{\"notice\":\"Emitted when conversion is paused\"},\"ConversionResumed(address)\":{\"notice\":\"Emitted when conversion is unpaused\"},\"ConvertedExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens\"},\"ConvertedExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\"},\"ConvertedForExactTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens\"},\"ConvertedForExactTokensSupportingFeeOnTransferTokens(address,address,address,address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\"},\"ConverterNetworkAddressUpdated(address,address)\":{\"notice\":\"Emitted when converterNetwork address is updated\"},\"DestinationAddressUpdated(address,address)\":{\"notice\":\"Emitted when destination address is updated\"},\"MinAmountToConvertUpdated(uint256,uint256)\":{\"notice\":\"Emitted when minimum amount to convert is updated\"},\"NewAccessControlManager(address,address)\":{\"notice\":\"Emitted when access control manager contract address is changed\"},\"PriceOracleUpdated(address,address)\":{\"notice\":\"Emitted when price oracle address is updated\"},\"SweepToken(address,address,uint256)\":{\"notice\":\"Event emitted when tokens are swept\"}},\"kind\":\"user\",\"methods\":{\"MAX_INCENTIVE()\":{\"notice\":\"Maximum incentive could be\"},\"accessControlManager()\":{\"notice\":\"Returns the address of the access control manager contract\"},\"assetsDirectTransfer(address)\":{\"notice\":\"The mapping contains the assets which are sent to destination directly\"},\"balanceOf(address)\":{\"notice\":\"Get the balance for specific token\"},\"baseAsset()\":{\"notice\":\"Address of the base asset token\"},\"conversionConfigurations(address,address)\":{\"notice\":\"conversion configurations for the existing pairs\"},\"conversionPaused()\":{\"notice\":\"Boolean for if conversion is paused\"},\"convertExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\"},\"convertForExactTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract, otherwise the amount is adjusted\"},\"convertForExactTokensSupportingFeeOnTransferTokens(uint256,uint256,address,address,address)\":{\"notice\":\"Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted. The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\"},\"converterNetwork()\":{\"notice\":\"Address of the converterNetwork contract\"},\"destinationAddress()\":{\"notice\":\"Address that all incoming tokens are transferred to\"},\"getAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut. This function does not account for potential token transfer fees(in case of deflationary tokens)\"},\"getAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn. This function does not account for potential token transfer fees(in case of deflationary tokens)The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\"},\"getUpdatedAmountIn(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\"},\"getUpdatedAmountOut(uint256,address,address)\":{\"notice\":\"To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\"},\"minAmountToConvert()\":{\"notice\":\"Min amount to convert for private conversions. Defined in USD, with 18 decimals\"},\"pauseConversion()\":{\"notice\":\"Pause conversion of tokens\"},\"priceOracle()\":{\"notice\":\"Venus price oracle contract\"},\"resumeConversion()\":{\"notice\":\"Resume conversion of tokens.\"},\"setAccessControlManager(address)\":{\"notice\":\"Sets the address of AccessControlManager\"},\"setAssetsDirectTransfer(address[],bool[])\":{\"notice\":\"Update the assetsDirectTransfer mapping\"},\"setBaseAsset(address)\":{\"notice\":\"Sets the base asset for the contract\"},\"setConversionConfig(address,address,(uint256,uint8))\":{\"notice\":\"Set the configuration for new or existing conversion pair\"},\"setConversionConfigs(address,address[],(uint256,uint8)[])\":{\"notice\":\"Batch sets the conversion configurations\"},\"setConverterNetwork(address)\":{\"notice\":\"Sets a converter network contract address\"},\"setDestination(address)\":{\"notice\":\"Sets a new destination address\"},\"setMinAmountToConvert(uint256)\":{\"notice\":\"Min amount to convert setter\"},\"setPriceOracle(address)\":{\"notice\":\"Sets a new price oracle\"},\"sweepToken(address,address,uint256)\":{\"notice\":\"To sweep ERC20 tokens and transfer them to user(to address)\"},\"updateAssetsState(address,address)\":{\"notice\":\"This method updated the states of this contract after getting funds from PSR after settling the amount(if any) through privateConversion between converters\"}},\"notice\":\"SingleTokenConverter used for token conversions and sends received tokens\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/TokenConverter/SingleTokenConverter.sol\":\"SingleTokenConverter\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./OwnableUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership} and {acceptOwnership}.\\n *\\n * This module is used through inheritance. It will make available all functions\\n * from parent (Ownable).\\n */\\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\\n function __Ownable2Step_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable2Step_init_unchained() internal onlyInitializing {\\n }\\n address private _pendingOwner;\\n\\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Returns the address of the pending owner.\\n */\\n function pendingOwner() public view virtual returns (address) {\\n return _pendingOwner;\\n }\\n\\n /**\\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual override onlyOwner {\\n _pendingOwner = newOwner;\\n emit OwnershipTransferStarted(owner(), newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual override {\\n delete _pendingOwner;\\n super._transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev The new owner accepts the ownership transfer.\\n */\\n function acceptOwnership() public virtual {\\n address sender = _msgSender();\\n require(pendingOwner() == sender, \\\"Ownable2Step: caller is not the new owner\\\");\\n _transferOwnership(sender);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x84efb8889801b0ac817324aff6acc691d07bbee816b671817132911d287a8c63\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n function __Ownable_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable_init_unchained() internal onlyInitializing {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby disabling any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x4075622496acc77fd6d4de4cc30a8577a744d5c75afad33fdeacf1704d6eda98\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts.\\n *\\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n * constructor.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n * are added through upgrades and that require initialization.\\n *\\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n * cannot be nested. If one is invoked in the context of another, execution will revert.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n *\\n * WARNING: setting the version to 255 will prevent any future reinitialization.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n *\\n * Emits an {Initialized} event the first time it is successfully executed.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized != type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n\\n /**\\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n */\\n function _getInitializedVersion() internal view returns (uint8) {\\n return _initialized;\\n }\\n\\n /**\\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n */\\n function _isInitializing() internal view returns (bool) {\\n return _initializing;\\n }\\n}\\n\",\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state.\\n */\\n function __Pausable_init() internal onlyInitializing {\\n __Pausable_init_unchained();\\n }\\n\\n function __Pausable_init_unchained() internal onlyInitializing {\\n _paused = false;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused() {\\n _requireNotPaused();\\n _;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier whenPaused() {\\n _requirePaused();\\n _;\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused() public view virtual returns (bool) {\\n return _paused;\\n }\\n\\n /**\\n * @dev Throws if the contract is paused.\\n */\\n function _requireNotPaused() internal view virtual {\\n require(!paused(), \\\"Pausable: paused\\\");\\n }\\n\\n /**\\n * @dev Throws if the contract is not paused.\\n */\\n function _requirePaused() internal view virtual {\\n require(paused(), \\\"Pausable: not paused\\\");\\n }\\n\\n /**\\n * @dev Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(_msgSender());\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n function __ReentrancyGuard_init() internal onlyInitializing {\\n __ReentrancyGuard_init_unchained();\\n }\\n\\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == _ENTERED;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xb82ef33f43b6b96109687d91b39c94573fdccaaa423fe28e8ba0977b31c023e0\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20PermitUpgradeable {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xd60f939a3ca0199014d079b4dd66aa757954334947d81eb5c1d35d7a83061ab3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\nimport \\\"../extensions/IERC20PermitUpgradeable.sol\\\";\\nimport \\\"../../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20Upgradeable {\\n using AddressUpgradeable for address;\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\\n * Revert on invalid signature.\\n */\\n function safePermit(\\n IERC20PermitUpgradeable token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return\\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));\\n }\\n}\\n\",\"keccak256\":\"0x23b997be73d3dd46885262704f0f8cfc7273fdadfe303d37969a9561373972b5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n *\\n * Furthermore, `isContract` will also return true if the target contract within\\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n * which only has an effect at the end of a transaction.\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal onlyInitializing {\\n }\\n\\n function __Context_init_unchained() internal onlyInitializing {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl {\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20Metadata is IERC20 {\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the symbol of the token.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the decimals places of the token.\\n */\\n function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\"},\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\\\";\\n\\nimport \\\"./IAccessControlManagerV8.sol\\\";\\n\\n/**\\n * @title AccessControlledV8\\n * @author Venus\\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.8.13)\\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\\n */\\nabstract contract AccessControlledV8 is Initializable, Ownable2StepUpgradeable {\\n /// @notice Access control manager contract\\n IAccessControlManagerV8 private _accessControlManager;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n\\n /// @notice Emitted when access control manager contract address is changed\\n event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\\n\\n /// @notice Thrown when the action is prohibited by AccessControlManager\\n error Unauthorized(address sender, address calledContract, string methodSignature);\\n\\n function __AccessControlled_init(address accessControlManager_) internal onlyInitializing {\\n __Ownable2Step_init();\\n __AccessControlled_init_unchained(accessControlManager_);\\n }\\n\\n function __AccessControlled_init_unchained(address accessControlManager_) internal onlyInitializing {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Sets the address of AccessControlManager\\n * @dev Admin function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n * @custom:event Emits NewAccessControlManager event\\n * @custom:access Only Governance\\n */\\n function setAccessControlManager(address accessControlManager_) external onlyOwner {\\n _setAccessControlManager(accessControlManager_);\\n }\\n\\n /**\\n * @notice Returns the address of the access control manager contract\\n */\\n function accessControlManager() external view returns (IAccessControlManagerV8) {\\n return _accessControlManager;\\n }\\n\\n /**\\n * @dev Internal function to set address of AccessControlManager\\n * @param accessControlManager_ The new address of the AccessControlManager\\n */\\n function _setAccessControlManager(address accessControlManager_) internal {\\n require(address(accessControlManager_) != address(0), \\\"invalid acess control manager address\\\");\\n address oldAccessControlManager = address(_accessControlManager);\\n _accessControlManager = IAccessControlManagerV8(accessControlManager_);\\n emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\\n }\\n\\n /**\\n * @notice Reverts if the call is not allowed by AccessControlManager\\n * @param signature Method signature\\n */\\n function _checkAccessAllowed(string memory signature) internal view {\\n bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\\n\\n if (!isAllowedToCall) {\\n revert Unauthorized(msg.sender, address(this), signature);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0dcf283925f4dddc23ca0ee71d2cb96a9dd6e4cf08061b69fde1697ea39dc514\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/access/IAccessControl.sol\\\";\\n\\n/**\\n * @title IAccessControlManagerV8\\n * @author Venus\\n * @notice Interface implemented by the `AccessControlManagerV8` contract.\\n */\\ninterface IAccessControlManagerV8 is IAccessControl {\\n function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\\n\\n function revokeCallPermission(\\n address contractAddress,\\n string calldata functionSig,\\n address accountToRevoke\\n ) external;\\n\\n function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\\n\\n function hasPermission(\\n address account,\\n address contractAddress,\\n string calldata functionSig\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xaa29b098440d0b3a131c5ecdf25ce548790c1b5ac7bf9b5c0264b6af6f7a1e0b\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/ResilientOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\n// SPDX-FileCopyrightText: 2022 Venus\\npragma solidity 0.8.25;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\nimport \\\"./interfaces/VBep20Interface.sol\\\";\\nimport \\\"./interfaces/OracleInterface.sol\\\";\\nimport \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\n\\n/**\\n * @title ResilientOracle\\n * @author Venus\\n * @notice The Resilient Oracle is the main contract that the protocol uses to fetch prices of assets.\\n *\\n * DeFi protocols are vulnerable to price oracle failures including oracle manipulation and incorrectly\\n * reported prices. If only one oracle is used, this creates a single point of failure and opens a vector\\n * for attacking the protocol.\\n *\\n * The Resilient Oracle uses multiple sources and fallback mechanisms to provide accurate prices and protect\\n * the protocol from oracle attacks. Currently it includes integrations with Chainlink, Pyth, Binance Oracle\\n * and TWAP (Time-Weighted Average Price) oracles. TWAP uses PancakeSwap as the on-chain price source.\\n *\\n * For every market (vToken) we configure the main, pivot and fallback oracles. The oracles are configured per\\n * vToken's underlying asset address. The main oracle oracle is the most trustworthy price source, the pivot\\n * oracle is used as a loose sanity checker and the fallback oracle is used as a backup price source.\\n *\\n * To validate prices returned from two oracles, we use an upper and lower bound ratio that is set for every\\n * market. The upper bound ratio represents the deviation between reported price (the price that\\u2019s being\\n * validated) and the anchor price (the price we are validating against) above which the reported price will\\n * be invalidated. The lower bound ratio presents the deviation between reported price and anchor price below\\n * which the reported price will be invalidated. So for oracle price to be considered valid the below statement\\n * should be true:\\n\\n```\\nanchorRatio = anchorPrice/reporterPrice\\nisValid = anchorRatio <= upperBoundAnchorRatio && anchorRatio >= lowerBoundAnchorRatio\\n```\\n\\n * In most cases, Chainlink is used as the main oracle, TWAP or Pyth oracles are used as the pivot oracle depending\\n * on which supports the given market and Binance oracle is used as the fallback oracle. For some markets we may\\n * use Pyth or TWAP as the main oracle if the token price is not supported by Chainlink or Binance oracles.\\n *\\n * For a fetched price to be valid it must be positive and not stagnant. If the price is invalid then we consider the\\n * oracle to be stagnant and treat it like it's disabled.\\n */\\ncontract ResilientOracle is PausableUpgradeable, AccessControlledV8, ResilientOracleInterface {\\n /**\\n * @dev Oracle roles:\\n * **main**: The most trustworthy price source\\n * **pivot**: Price oracle used as a loose sanity checker\\n * **fallback**: The backup source when main oracle price is invalidated\\n */\\n enum OracleRole {\\n MAIN,\\n PIVOT,\\n FALLBACK\\n }\\n\\n struct TokenConfig {\\n /// @notice asset address\\n address asset;\\n /// @notice `oracles` stores the oracles based on their role in the following order:\\n /// [main, pivot, fallback],\\n /// It can be indexed with the corresponding enum OracleRole value\\n address[3] oracles;\\n /// @notice `enableFlagsForOracles` stores the enabled state\\n /// for each oracle in the same order as `oracles`\\n bool[3] enableFlagsForOracles;\\n }\\n\\n uint256 public constant INVALID_PRICE = 0;\\n\\n /// @notice Native market address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable nativeMarket;\\n\\n /// @notice VAI address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address public immutable vai;\\n\\n /// @notice Set this as asset address for Native token on each chain.This is the underlying for vBNB (on bsc)\\n /// and can serve as any underlying asset of a market that supports native tokens\\n address public constant NATIVE_TOKEN_ADDR = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\\n\\n /// @notice Bound validator contract address\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n BoundValidatorInterface public immutable boundValidator;\\n\\n mapping(address => TokenConfig) private tokenConfigs;\\n\\n event TokenConfigAdded(\\n address indexed asset,\\n address indexed mainOracle,\\n address indexed pivotOracle,\\n address fallbackOracle\\n );\\n\\n /// Event emitted when an oracle is set\\n event OracleSet(address indexed asset, address indexed oracle, uint256 indexed role);\\n\\n /// Event emitted when an oracle is enabled or disabled\\n event OracleEnabled(address indexed asset, uint256 indexed role, bool indexed enable);\\n\\n /**\\n * @notice Checks whether an address is null or not\\n */\\n modifier notNullAddress(address someone) {\\n if (someone == address(0)) revert(\\\"can't be zero address\\\");\\n _;\\n }\\n\\n /**\\n * @notice Checks whether token config exists by checking whether asset is null address\\n * @dev address can't be null, so it's suitable to be used to check the validity of the config\\n * @param asset asset address\\n */\\n modifier checkTokenConfigExistence(address asset) {\\n if (tokenConfigs[asset].asset == address(0)) revert(\\\"token config must exist\\\");\\n _;\\n }\\n\\n /// @notice Constructor for the implementation contract. Sets immutable variables.\\n /// @dev nativeMarketAddress can be address(0) if on the chain we do not support native market\\n /// (e.g vETH on ethereum would not be supported, only vWETH)\\n /// @param nativeMarketAddress The address of a native market (for bsc it would be vBNB address)\\n /// @param vaiAddress The address of the VAI token (if there is VAI on the deployed chain).\\n /// Set to address(0) of VAI is not existent.\\n /// @param _boundValidator Address of the bound validator contract\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor(\\n address nativeMarketAddress,\\n address vaiAddress,\\n BoundValidatorInterface _boundValidator\\n ) notNullAddress(address(_boundValidator)) {\\n nativeMarket = nativeMarketAddress;\\n vai = vaiAddress;\\n boundValidator = _boundValidator;\\n\\n _disableInitializers();\\n }\\n\\n /**\\n * @notice Initializes the contract admin and sets the BoundValidator contract address\\n * @param accessControlManager_ Address of the access control manager contract\\n */\\n function initialize(address accessControlManager_) external initializer {\\n __AccessControlled_init(accessControlManager_);\\n __Pausable_init();\\n }\\n\\n /**\\n * @notice Pauses oracle\\n * @custom:access Only Governance\\n */\\n function pause() external {\\n _checkAccessAllowed(\\\"pause()\\\");\\n _pause();\\n }\\n\\n /**\\n * @notice Unpauses oracle\\n * @custom:access Only Governance\\n */\\n function unpause() external {\\n _checkAccessAllowed(\\\"unpause()\\\");\\n _unpause();\\n }\\n\\n /**\\n * @notice Batch sets token configs\\n * @param tokenConfigs_ Token config array\\n * @custom:access Only Governance\\n * @custom:error Throws a length error if the length of the token configs array is 0\\n */\\n function setTokenConfigs(TokenConfig[] memory tokenConfigs_) external {\\n if (tokenConfigs_.length == 0) revert(\\\"length can't be 0\\\");\\n uint256 numTokenConfigs = tokenConfigs_.length;\\n for (uint256 i; i < numTokenConfigs; ) {\\n setTokenConfig(tokenConfigs_[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /**\\n * @notice Sets oracle for a given asset and role.\\n * @dev Supplied asset **must** exist and main oracle may not be null\\n * @param asset Asset address\\n * @param oracle Oracle address\\n * @param role Oracle role\\n * @custom:access Only Governance\\n * @custom:error Null address error if main-role oracle address is null\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n * @custom:event Emits OracleSet event with asset address, oracle address and role of the oracle for the asset\\n */\\n function setOracle(\\n address asset,\\n address oracle,\\n OracleRole role\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"setOracle(address,address,uint8)\\\");\\n if (oracle == address(0) && role == OracleRole.MAIN) revert(\\\"can't set zero address to main oracle\\\");\\n tokenConfigs[asset].oracles[uint256(role)] = oracle;\\n emit OracleSet(asset, oracle, uint256(role));\\n }\\n\\n /**\\n * @notice Enables/ disables oracle for the input asset. Token config for the input asset **must** exist\\n * @dev Configuration for the asset **must** already exist and the asset cannot be 0 address\\n * @param asset Asset address\\n * @param role Oracle role\\n * @param enable Enabled boolean of the oracle\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress error is thrown if asset address is null\\n * @custom:error TokenConfigExistance error is thrown if token config is not set\\n */\\n function enableOracle(\\n address asset,\\n OracleRole role,\\n bool enable\\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\\n _checkAccessAllowed(\\\"enableOracle(address,uint8,bool)\\\");\\n tokenConfigs[asset].enableFlagsForOracles[uint256(role)] = enable;\\n emit OracleEnabled(asset, uint256(role), enable);\\n }\\n\\n /**\\n * @notice Updates the TWAP pivot oracle price.\\n * @dev This function should always be called before calling getUnderlyingPrice\\n * @param vToken vToken address\\n */\\n function updatePrice(address vToken) external override {\\n address asset = _getUnderlyingAsset(vToken);\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @notice Updates the pivot oracle price. Currently using TWAP\\n * @dev This function should always be called before calling getPrice\\n * @param asset asset address\\n */\\n function updateAssetPrice(address asset) external {\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracle != address(0) && pivotOracleEnabled) {\\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\\n }\\n }\\n\\n /**\\n * @dev Gets token config by asset address\\n * @param asset asset address\\n * @return tokenConfig Config for the asset\\n */\\n function getTokenConfig(address asset) external view returns (TokenConfig memory) {\\n return tokenConfigs[asset];\\n }\\n\\n /**\\n * @notice Gets price of the underlying asset for a given vToken. Validation flow:\\n * - Check if the oracle is paused globally\\n * - Validate price from main oracle against pivot oracle\\n * - Validate price from fallback oracle against pivot oracle if the first validation failed\\n * - Validate price from main oracle against fallback oracle if the second validation failed\\n * In the case that the pivot oracle is not available but main price is available and validation is successful,\\n * main oracle price is returned.\\n * @param vToken vToken address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getUnderlyingPrice(address vToken) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n\\n address asset = _getUnderlyingAsset(vToken);\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Gets price of the asset\\n * @param asset asset address\\n * @return price USD price in scaled decimal places.\\n * @custom:error Paused error is thrown when resilent oracle is paused\\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\\n */\\n function getPrice(address asset) external view override returns (uint256) {\\n if (paused()) revert(\\\"resilient oracle is paused\\\");\\n return _getPrice(asset);\\n }\\n\\n /**\\n * @notice Sets/resets single token configs.\\n * @dev main oracle **must not** be a null address\\n * @param tokenConfig Token config struct\\n * @custom:access Only Governance\\n * @custom:error NotNullAddress is thrown if asset address is null\\n * @custom:error NotNullAddress is thrown if main-role oracle address for asset is null\\n * @custom:event Emits TokenConfigAdded event when the asset config is set successfully by the authorized account\\n */\\n function setTokenConfig(\\n TokenConfig memory tokenConfig\\n ) public notNullAddress(tokenConfig.asset) notNullAddress(tokenConfig.oracles[uint256(OracleRole.MAIN)]) {\\n _checkAccessAllowed(\\\"setTokenConfig(TokenConfig)\\\");\\n\\n tokenConfigs[tokenConfig.asset] = tokenConfig;\\n emit TokenConfigAdded(\\n tokenConfig.asset,\\n tokenConfig.oracles[uint256(OracleRole.MAIN)],\\n tokenConfig.oracles[uint256(OracleRole.PIVOT)],\\n tokenConfig.oracles[uint256(OracleRole.FALLBACK)]\\n );\\n }\\n\\n /**\\n * @notice Gets oracle and enabled status by asset address\\n * @param asset asset address\\n * @param role Oracle role\\n * @return oracle Oracle address based on role\\n * @return enabled Enabled flag of the oracle based on token config\\n */\\n function getOracle(address asset, OracleRole role) public view returns (address oracle, bool enabled) {\\n oracle = tokenConfigs[asset].oracles[uint256(role)];\\n enabled = tokenConfigs[asset].enableFlagsForOracles[uint256(role)];\\n }\\n\\n function _getPrice(address asset) internal view returns (uint256) {\\n uint256 pivotPrice = INVALID_PRICE;\\n\\n // Get pivot oracle price, Invalid price if not available or error\\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\\n if (pivotOracleEnabled && pivotOracle != address(0)) {\\n try OracleInterface(pivotOracle).getPrice(asset) returns (uint256 pricePivot) {\\n pivotPrice = pricePivot;\\n } catch {}\\n }\\n\\n // Compare main price and pivot price, return main price and if validation was successful\\n // note: In case pivot oracle is not available but main price is available and\\n // validation is successful, the main oracle price is returned.\\n (uint256 mainPrice, bool validatedPivotMain) = _getMainOraclePrice(\\n asset,\\n pivotPrice,\\n pivotOracleEnabled && pivotOracle != address(0)\\n );\\n if (mainPrice != INVALID_PRICE && validatedPivotMain) return mainPrice;\\n\\n // Compare fallback and pivot if main oracle comparision fails with pivot\\n // Return fallback price when fallback price is validated successfully with pivot oracle\\n (uint256 fallbackPrice, bool validatedPivotFallback) = _getFallbackOraclePrice(asset, pivotPrice);\\n if (fallbackPrice != INVALID_PRICE && validatedPivotFallback) return fallbackPrice;\\n\\n // Lastly compare main price and fallback price\\n if (\\n mainPrice != INVALID_PRICE &&\\n fallbackPrice != INVALID_PRICE &&\\n boundValidator.validatePriceWithAnchorPrice(asset, mainPrice, fallbackPrice)\\n ) {\\n return mainPrice;\\n }\\n\\n revert(\\\"invalid resilient oracle price\\\");\\n }\\n\\n /**\\n * @notice Gets a price for the provided asset\\n * @dev This function won't revert when price is 0, because the fallback oracle may still be\\n * able to fetch a correct price\\n * @param asset asset address\\n * @param pivotPrice Pivot oracle price\\n * @param pivotEnabled If pivot oracle is not empty and enabled\\n * @return price USD price in scaled decimals\\n * e.g. asset decimals is 8 then price is returned as 10**18 * 10**(18-8) = 10**28 decimals\\n * @return pivotValidated Boolean representing if the validation of main oracle price\\n * and pivot oracle price were successful\\n * @custom:error Invalid price error is thrown if main oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if main oracle is not enabled or main oracle\\n * address is null\\n */\\n function _getMainOraclePrice(\\n address asset,\\n uint256 pivotPrice,\\n bool pivotEnabled\\n ) internal view returns (uint256, bool) {\\n (address mainOracle, bool mainOracleEnabled) = getOracle(asset, OracleRole.MAIN);\\n if (mainOracleEnabled && mainOracle != address(0)) {\\n try OracleInterface(mainOracle).getPrice(asset) returns (uint256 mainOraclePrice) {\\n if (!pivotEnabled) {\\n return (mainOraclePrice, true);\\n }\\n if (pivotPrice == INVALID_PRICE) {\\n return (mainOraclePrice, false);\\n }\\n return (\\n mainOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, mainOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function won't revert when the price is 0 because getPrice checks if price is > 0\\n * @param asset asset address\\n * @return price USD price in 18 decimals\\n * @return pivotValidated Boolean representing if the validation of fallback oracle price\\n * and pivot oracle price were successfully\\n * @custom:error Invalid price error is thrown if fallback oracle fails to fetch price of the asset\\n * @custom:error Invalid price error is thrown if fallback oracle is not enabled or fallback oracle\\n * address is null\\n */\\n function _getFallbackOraclePrice(address asset, uint256 pivotPrice) private view returns (uint256, bool) {\\n (address fallbackOracle, bool fallbackEnabled) = getOracle(asset, OracleRole.FALLBACK);\\n if (fallbackEnabled && fallbackOracle != address(0)) {\\n try OracleInterface(fallbackOracle).getPrice(asset) returns (uint256 fallbackOraclePrice) {\\n if (pivotPrice == INVALID_PRICE) {\\n return (fallbackOraclePrice, false);\\n }\\n return (\\n fallbackOraclePrice,\\n boundValidator.validatePriceWithAnchorPrice(asset, fallbackOraclePrice, pivotPrice)\\n );\\n } catch {\\n return (INVALID_PRICE, false);\\n }\\n }\\n\\n return (INVALID_PRICE, false);\\n }\\n\\n /**\\n * @dev This function returns the underlying asset of a vToken\\n * @param vToken vToken address\\n * @return asset underlying asset address\\n */\\n function _getUnderlyingAsset(address vToken) private view notNullAddress(vToken) returns (address asset) {\\n if (vToken == nativeMarket) {\\n asset = NATIVE_TOKEN_ADDR;\\n } else if (vToken == vai) {\\n asset = vai;\\n } else {\\n asset = VBep20Interface(vToken).underlying();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xdaaa90daa8ca5bda477729aaa5d5ff3e5305635baec1799a368d564ae2a13c4c\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\ninterface OracleInterface {\\n function getPrice(address asset) external view returns (uint256);\\n}\\n\\ninterface ResilientOracleInterface is OracleInterface {\\n function updatePrice(address vToken) external;\\n\\n function updateAssetPrice(address asset) external;\\n\\n function getUnderlyingPrice(address vToken) external view returns (uint256);\\n}\\n\\ninterface TwapInterface is OracleInterface {\\n function updateTwap(address asset) external returns (uint256);\\n}\\n\\ninterface BoundValidatorInterface {\\n function validatePriceWithAnchorPrice(\\n address asset,\\n uint256 reporterPrice,\\n uint256 anchorPrice\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x2432799b0d824fc701beb4c30146e912b9aeecf77b5c1635dde6c5fbe6bfc3a7\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/oracle/contracts/interfaces/VBep20Interface.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\ninterface VBep20Interface is IERC20Metadata {\\n /**\\n * @notice Underlying asset for this VToken\\n */\\n function underlying() external view returns (address);\\n}\\n\",\"keccak256\":\"0x6e71c3df86501df5c0e4bace1333c0c91f9f9cced252a54fb99eeda219b789d5\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/constants.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\n/// @dev Base unit for computations, usually used in scaling (multiplications, divisions)\\nuint256 constant EXP_SCALE = 1e18;\\n\\n/// @dev A unit (literal one) in EXP_SCALE, usually used in additions/subtractions\\nuint256 constant MANTISSA_ONE = EXP_SCALE;\\n\\n/// @dev The approximate number of seconds per year\\nuint256 constant SECONDS_PER_YEAR = 31_536_000;\\n\",\"keccak256\":\"0x14de93ead464da249af31bea0e3bcfb62ec693bea3475fb4d90f055ac81dc5eb\",\"license\":\"BSD-3-Clause\"},\"@venusprotocol/solidity-utilities/contracts/validators.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\n/// @notice Thrown if the supplied address is a zero address where it is not allowed\\nerror ZeroAddressNotAllowed();\\n\\n/// @notice Thrown if the supplied value is 0 where it is not allowed\\nerror ZeroValueNotAllowed();\\n\\n/// @notice Checks if the provided address is nonzero, reverts otherwise\\n/// @param address_ Address to check\\n/// @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address\\nfunction ensureNonzeroAddress(address address_) pure {\\n if (address_ == address(0)) {\\n revert ZeroAddressNotAllowed();\\n }\\n}\\n\\n/// @notice Checks if the provided value is nonzero, reverts otherwise\\n/// @param value_ Value to check\\n/// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\nfunction ensureNonzeroValue(uint256 value_) pure {\\n if (value_ == 0) {\\n revert ZeroValueNotAllowed();\\n }\\n}\\n\",\"keccak256\":\"0xdb88e14d50dd21889ca3329d755673d022c47e8da005b6a545c7f69c2c4b7b86\",\"license\":\"BSD-3-Clause\"},\"contracts/Interfaces/IConverterNetwork.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { IAbstractTokenConverter } from \\\"../TokenConverter/IAbstractTokenConverter.sol\\\";\\n\\n/**\\n * @title IConverterNetwork\\n * @author Venus\\n * @notice Interface implemented by `ConverterNetwork`.\\n */\\ninterface IConverterNetwork {\\n /// @notice Adds new converter to the array\\n /// @param _tokenConverter Address of the token converter\\n function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Removes converter from the array\\n /// @param _tokenConverter Address of the token converter\\n function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\\n /// @param _tokenAddressIn Address of tokenIn\\n /// @param _tokenAddressOut Address of tokenOut\\n /// @return converters Array of the conveters on the basis of the tokens pair\\n /// @return convertersBalance Array of balances with respect to token out\\n function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)\\n external\\n returns (address[] memory converters, uint256[] memory convertersBalance);\\n\\n /// @notice This function returns the array containing all the converters addresses\\n /// @return Array containing all the converters addresses\\n function getAllConverters() external view returns (IAbstractTokenConverter[] memory);\\n\\n /// @notice This function checks for given address is converter or not\\n /// @param _tokenConverter Address of the token converter\\n /// @return boolean true if given address is converter otherwise false\\n function isTokenConverter(address _tokenConverter) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xd9a747f176d9b9de220331b87ed711cc2bd594a118b538a35f3c47060bff7a8b\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/AbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { ReentrancyGuardUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { AccessControlledV8 } from \\\"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress, ensureNonzeroValue } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\nimport { MANTISSA_ONE, EXP_SCALE } from \\\"@venusprotocol/solidity-utilities/contracts/constants.sol\\\";\\n\\nimport { IAbstractTokenConverter } from \\\"./IAbstractTokenConverter.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @title AbstractTokenConverter\\n/// @author Venus\\n/// @notice Abstract contract will be extended by SingleTokenConverter and RiskFundConverter\\n/*\\n * This contract specifies four functions for converting tokens, each applicable under following circumstances:\\n *\\n * Case I: TokenIn -> deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions supporting fees can only be utilized to convert tokens which are:\\n * a. convertExactTokensSupportingFeeOnTransferTokens\\n * b. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case II: TokenIn -> deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions supporting fee can only be utilized to convert tokens which are:\\n * similar to Case I.\\n *\\n * Case III: TokenIn -> non-deflationary token, TokenOut -> deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * a. convertExactTokens\\n * b. convertForExactTokens\\n * c. convertExactTokensSupportingFeeOnTransferTokens\\n * d. convertForExactTokensSupportingFeeOnTransferTokens\\n *\\n * Case IV: TokenIn -> non-deflationary token, TokenOut -> non-deflationary token\\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\\n * similar to Case III.\\n *\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n * Example 1:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInAmount - 100\\n * tokenOutMinAmount - minimum amount desired by the user(let's say 70)\\n * Here user can use `convertExactTokens` or `convertExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertExactTokens` is used).\\n * Now first tokenInAddress tokens will be transferred from the user to the contract, on the basis of amount\\n * received(as tokenInAddress can be deflationary token) tokenAmountOut will be calculated and will be transferred\\n * to the user and if amount sent is less than tokenOutMinAmount, tx will revert. If amount sent is satisfied(let's say\\n * 80 or even 70) then at last the actual amount received and the amount that was supposed to be received by the contract will\\n * be compared, if they differ then the whole tx will revert as user was supposed to use `convertExactTokensSupportingFeeOnTransferTokens`\\n * function for tokenIn as deflationary token.\\n *\\n * Example 2:-\\n * tokenInAddress - 0xaaaa.....\\n * tokenOutAddress - 0xbbbb.....\\n * tokenInMaxAmount - maximum amount user is willing to provide(let's say 100)\\n * tokenOutAmount - 70\\n * Here user can use `convertForExactTokens` or `convertForExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\\n * then `convertForExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertForExactTokens` is used),\\n * which on the basis of tokenOutAmount provided will calculate tokenInAmount based on the tokens prices and will transfer\\n * tokens from the user to the contract, now the actual amount received(as tokenInAddress can be deflationary token) will be\\n * compared with tokenInMaxAmount if it is greater, tx will revert. If In amount is satisfied(let's say 90 or even 100) then\\n * new tokenOutAmount will be calculated, and tokenOutAddress tokens will be transferred to the user, but at last the\\n * old tokenOutAmount and new tokenOutAmount will be compared and if they differ whole tx will revert, because user was\\n * supposed to use `convertForExactTokensSupportingFeeOnTransferTokens` function for tokenIn as deflationary token.\\n * ------------------------------------------------------------------------------------------------------------------------------------\\n *\\n * This contract also supports private conversion between the converters:\\n * Private conversions:\\n * Private conversions is designed in order to convert the maximum amount of tokens received from PSR(to any converter) between\\n * existing converters to save incentive and lower the dependency of users for conversion. So Private Conversion will be executed\\n * by converters on it's own whenever funds are received from PSR. No incentive will be offered during private conversion.\\n *\\n * It will execute on updateAssetsState() function call in Converter Contracts. After this function call, converter will first\\n * check for the amount received. If base asset is received then it will be directly sent to the destination address and no private\\n * conversion will happen otherwise converter will interact with ConverterNetwork contract to find other valid converters who are providing the conversion for:\\n *\\n * tokenAddressIn: As asset received by that converter on updateAssetsState() function call.\\n * tokenAddressOut: As base asset of that converter.\\n *\\n * ConverterNetwork:\\n * This contract will contain all the converters, and will provide valid converters which can perform the execution according to tokenAddressIn\\n * and tokenAddressOut provided.\\n *\\n * findTokenConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for users).\\n *\\n * findTokenConvertersForConverters():\\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for converters).\\n */\\n\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\nabstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenConverter, ReentrancyGuardUpgradeable {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Maximum incentive could be\\n uint256 public constant MAX_INCENTIVE = 0.5e18;\\n\\n /// @notice Min amount to convert for private conversions. Defined in USD, with 18 decimals\\n uint256 public minAmountToConvert;\\n\\n /// @notice Venus price oracle contract\\n ResilientOracle public priceOracle;\\n\\n /// @notice conversion configurations for the existing pairs\\n /// @dev tokenAddressIn => tokenAddressOut => ConversionConfig\\n mapping(address => mapping(address => ConversionConfig)) public conversionConfigurations;\\n\\n /// @notice Address that all incoming tokens are transferred to\\n address public destinationAddress;\\n\\n /// @notice Boolean for if conversion is paused\\n bool public conversionPaused;\\n\\n /// @notice Address of the converterNetwork contract\\n IConverterNetwork public converterNetwork;\\n\\n /// @dev This empty reserved space is put in place to allow future versions to add new\\n /// variables without shifting down storage in the inheritance chain.\\n /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n uint256[45] private __gap;\\n\\n /// @notice Emitted when config is updated for tokens pair\\n event ConversionConfigUpdated(\\n address indexed tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 oldIncentive,\\n uint256 newIncentive,\\n ConversionAccessibility oldAccess,\\n ConversionAccessibility newAccess\\n );\\n /// @notice Emitted when price oracle address is updated\\n event PriceOracleUpdated(ResilientOracle indexed oldPriceOracle, ResilientOracle indexed priceOracle);\\n\\n /// @notice Emitted when destination address is updated\\n event DestinationAddressUpdated(address indexed oldDestinationAddress, address indexed destinationAddress);\\n\\n /// @notice Emitted when converterNetwork address is updated\\n event ConverterNetworkAddressUpdated(address indexed oldConverterNetwork, address indexed converterNetwork);\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens\\n event ConvertedExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens\\n event ConvertedForExactTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\\n event ConvertedExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\\n event ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n address indexed sender,\\n address indexed receiver,\\n address tokenAddressIn,\\n address indexed tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n );\\n\\n /// @notice Emitted when conversion is paused\\n event ConversionPaused(address indexed sender);\\n\\n /// @notice Emitted when conversion is unpaused\\n event ConversionResumed(address indexed sender);\\n\\n /// @notice Event emitted when tokens are swept\\n event SweepToken(address indexed token, address indexed to, uint256 amount);\\n\\n /// @notice Emitted when minimum amount to convert is updated\\n event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);\\n\\n /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\\n error AmountOutMismatched();\\n\\n /// @notice Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\\n error AmountInMismatched();\\n\\n /// @notice Thrown when given input amount is zero\\n error InsufficientInputAmount();\\n\\n /// @notice Thrown when given output amount is zero\\n error InsufficientOutputAmount();\\n\\n /// @notice Thrown when conversion is disabled or config does not exist for given pair\\n error ConversionConfigNotEnabled();\\n\\n /// @notice Thrown when conversion is enabled only for private conversions\\n error ConversionEnabledOnlyForPrivateConversions();\\n\\n /// @notice Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n error InvalidToAddress();\\n\\n /// @notice Thrown when incentive is higher than the MAX_INCENTIVE\\n error IncentiveTooHigh(uint256 incentive, uint256 maxIncentive);\\n\\n /// @notice Thrown when amountOut is lower than amountOutMin\\n error AmountOutLowerThanMinRequired(uint256 amountOutMantissa, uint256 amountOutMinMantissa);\\n\\n /// @notice Thrown when amountIn is higher than amountInMax\\n error AmountInHigherThanMax(uint256 amountInMantissa, uint256 amountInMaxMantissa);\\n\\n /// @notice Thrown when conversion is paused\\n error ConversionTokensPaused();\\n\\n /// @notice Thrown when conversion is Active\\n error ConversionTokensActive();\\n\\n /// @notice Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\\n error InvalidTokenConfigAddresses();\\n\\n /// @notice Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\\n error InsufficientPoolLiquidity();\\n\\n /// @notice When address of the ConverterNetwork is not set or Zero address\\n error InvalidConverterNetwork();\\n\\n /// @notice Thrown when trying to set non zero incentive for private conversion\\n error NonZeroIncentiveForPrivateConversion();\\n\\n /// @notice Thrown when using convertForExactTokens deflationary tokens\\n error DeflationaryTokenNotSupported();\\n\\n /// @notice Thrown when minimum amount to convert is zero\\n error InvalidMinimumAmountToConvert();\\n\\n /// @notice Thrown when there is a mismatch in the length of input arrays\\n error InputLengthMisMatch();\\n\\n /**\\n * @notice Modifier to ensure valid conversion parameters for a token conversion\\n * and check if conversion is paused or not\\n * @param to The recipient address for the converted tokens\\n * @param tokenAddressIn The input token address for the conversion\\n * @param tokenAddressOut The output token address for the conversion\\n */\\n modifier validConversionParameters(\\n address to,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) {\\n _checkConversionPaused();\\n ensureNonzeroAddress(to);\\n if (to == tokenAddressIn || to == tokenAddressOut) {\\n revert InvalidToAddress();\\n }\\n _;\\n }\\n\\n /// @notice Pause conversion of tokens\\n /// @custom:event Emits ConversionPaused on success\\n /// @custom:error ConversionTokensPaused thrown when conversion is already paused\\n /// @custom:access Restricted by ACM\\n function pauseConversion() external {\\n _checkAccessAllowed(\\\"pauseConversion()\\\");\\n _checkConversionPaused();\\n conversionPaused = true;\\n emit ConversionPaused(msg.sender);\\n }\\n\\n /// @notice Resume conversion of tokens.\\n /// @custom:event Emits ConversionResumed on success\\n /// @custom:error ConversionTokensActive thrown when conversion is already active\\n /// @custom:access Restricted by ACM\\n function resumeConversion() external {\\n _checkAccessAllowed(\\\"resumeConversion()\\\");\\n if (!conversionPaused) {\\n revert ConversionTokensActive();\\n }\\n\\n conversionPaused = false;\\n emit ConversionResumed(msg.sender);\\n }\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:access Only Governance\\n function setPriceOracle(ResilientOracle priceOracle_) external onlyOwner {\\n _setPriceOracle(priceOracle_);\\n }\\n\\n /// @notice Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:access Only Governance\\n function setDestination(address destinationAddress_) external onlyOwner {\\n _setDestination(destinationAddress_);\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:access Only Governance\\n function setConverterNetwork(IConverterNetwork converterNetwork_) external onlyOwner {\\n _setConverterNetwork(converterNetwork_);\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:access Only Governance\\n function setMinAmountToConvert(uint256 minAmountToConvert_) external {\\n _checkAccessAllowed(\\\"setMinAmountToConvert(uint256)\\\");\\n _setMinAmountToConvert(minAmountToConvert_);\\n }\\n\\n /// @notice Batch sets the conversion configurations\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressesOut Array of addresses of tokenOut\\n /// @param conversionConfigs Array of conversionConfig config details to update\\n /// @custom:error InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\\n function setConversionConfigs(\\n address tokenAddressIn,\\n address[] calldata tokenAddressesOut,\\n ConversionConfig[] calldata conversionConfigs\\n ) external {\\n uint256 tokenOutArrayLength = tokenAddressesOut.length;\\n if (tokenOutArrayLength != conversionConfigs.length) revert InputLengthMisMatch();\\n\\n for (uint256 i; i < tokenOutArrayLength; ) {\\n setConversionConfig(tokenAddressIn, tokenAddressesOut[i], conversionConfigs[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n /// @custom:error AmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert AmountInMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract,\\n /// otherwise the amount is adjusted\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n /// @custom:error AmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n if (actualAmountOut != amountOutMantissa) {\\n revert AmountOutMismatched();\\n }\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n }\\n\\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\\n amountInMantissa,\\n amountOutMinMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of\\n /// tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted.\\n /// The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount transferred to destination\\n /// @return actualAmountOut Actual amount transferred to user\\n /// @custom:event Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n )\\n external\\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\\n nonReentrant\\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\\n {\\n (actualAmountIn, actualAmountOut) = _convertForExactTokensSupportingFeeOnTransferTokens(\\n amountInMaxMantissa,\\n amountOutMantissa,\\n tokenAddressIn,\\n tokenAddressOut,\\n to\\n );\\n\\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\\n emit ConvertedForExactTokensSupportingFeeOnTransferTokens(\\n msg.sender,\\n to,\\n tokenAddressIn,\\n tokenAddressOut,\\n actualAmountIn,\\n actualAmountOut\\n );\\n }\\n\\n /// @notice To sweep ERC20 tokens and transfer them to user(to address)\\n /// @param tokenAddress The address of the ERC-20 token to sweep\\n /// @param to The address to which tokens will be transferred\\n /// @param amount The amount to transfer\\n /// @custom:event Emits SweepToken event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\\n /// @custom:access Only Governance\\n function sweepToken(\\n address tokenAddress,\\n address to,\\n uint256 amount\\n ) external onlyOwner nonReentrant {\\n ensureNonzeroAddress(tokenAddress);\\n ensureNonzeroAddress(to);\\n ensureNonzeroValue(amount);\\n\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n preSweepToken(tokenAddress, amount);\\n token.safeTransfer(to, amount);\\n\\n emit SweepToken(tokenAddress, to, amount);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @notice The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n amountConvertedMantissa = amountInMantissa;\\n uint256 tokenInToOutConversion;\\n (amountOutMantissa, tokenInToOutConversion) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountConvertedMantissa = _divRoundingUp(maxTokenOutReserve * EXP_SCALE, tokenInToOutConversion);\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut.\\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\\n /// @dev This function retrieves values without altering token prices\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n if (\\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountOutMantissa) {\\n amountOutMantissa = maxTokenOutReserve;\\n }\\n\\n amountConvertedMantissa = amountOutMantissa;\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountOutMantissa, ) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountInMantissa;\\n }\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) public returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\\n priceOracle.updateAssetPrice(tokenAddressIn);\\n priceOracle.updateAssetPrice(tokenAddressOut);\\n\\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n amountConvertedMantissa = amountOutMantissa;\\n }\\n\\n /// @notice This method updated the states of this contract after getting funds from PSR\\n /// after settling the amount(if any) through privateConversion between converters\\n /// @dev This function is called by protocolShareReserve\\n /// @dev call _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then\\n /// it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n function updateAssetsState(address comptroller, address asset) public nonReentrant {\\n uint256 balanceDiff = _updateAssetsState(comptroller, asset);\\n if (balanceDiff > 0) {\\n _privateConversion(comptroller, asset, balanceDiff);\\n }\\n }\\n\\n /// @notice Set the configuration for new or existing conversion pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n /// @custom:event Emits ConversionConfigUpdated event on success\\n /// @custom:error Unauthorized error is thrown when the call is not authorized by AccessControlManager\\n /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero\\n /// @custom:error NonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\\n /// @custom:access Controlled by AccessControlManager\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) public {\\n _checkAccessAllowed(\\\"setConversionConfig(address,address,ConversionConfig)\\\");\\n ensureNonzeroAddress(tokenAddressIn);\\n ensureNonzeroAddress(tokenAddressOut);\\n\\n if (conversionConfig.incentive > MAX_INCENTIVE) {\\n revert IncentiveTooHigh(conversionConfig.incentive, MAX_INCENTIVE);\\n }\\n\\n if (\\n (tokenAddressIn == tokenAddressOut) ||\\n (tokenAddressIn != _getDestinationBaseAsset()) ||\\n conversionConfigurations[tokenAddressOut][tokenAddressIn].conversionAccess != ConversionAccessibility.NONE\\n ) {\\n revert InvalidTokenConfigAddresses();\\n }\\n\\n if (\\n (conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) &&\\n conversionConfig.incentive != 0\\n ) {\\n revert NonZeroIncentiveForPrivateConversion();\\n }\\n\\n if (\\n ((conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) ||\\n (conversionConfig.conversionAccess == ConversionAccessibility.ALL)) &&\\n (address(converterNetwork) == address(0))\\n ) {\\n revert InvalidConverterNetwork();\\n }\\n\\n ConversionConfig storage configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n emit ConversionConfigUpdated(\\n tokenAddressIn,\\n tokenAddressOut,\\n configuration.incentive,\\n conversionConfig.incentive,\\n configuration.conversionAccess,\\n conversionConfig.conversionAccess\\n );\\n\\n if (conversionConfig.conversionAccess == ConversionAccessibility.NONE) {\\n delete conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n } else {\\n configuration.incentive = conversionConfig.incentive;\\n configuration.conversionAccess = conversionConfig.conversionAccess;\\n }\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) public view virtual returns (uint256 tokenBalance);\\n\\n /// @dev Operations to perform before sweeping tokens\\n /// @param token Address of the token\\n /// @param amount Amount transferred to address(to)\\n function preSweepToken(address token, uint256 amount) internal virtual {}\\n\\n /// @dev Converts exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return amountOutMantissa Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\\n function _convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 amountOutMantissa) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, amountOutMantissa) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n if (amountOutMantissa < amountOutMinMantissa) {\\n revert AmountOutLowerThanMinRequired(amountOutMantissa, amountOutMinMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for exact amount of tokenAddressOut used for non deflationry tokens\\n /// it is called by convertForExactTokens function\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error DeflationaryTokenNotSupported is thrown if tokenAddressIn is deflationary token\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n if (actualAmountIn != amountInMantissa) {\\n revert DeflationaryTokenNotSupported();\\n }\\n\\n if (actualAmountIn > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\\n actualAmountOut = amountOutMantissa;\\n }\\n\\n /// @dev Converts tokens for tokenAddressIn for the amount of tokenAddressOut used for deflationary tokens\\n /// it is called by convertForExactTokensSupportingFeeOnTransferTokens function\\n /// @notice Advising users to input a smaller amountOutMantissa to avoid potential transaction revert\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\\n function _convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\\n\\n if (amountInMantissa > amountInMaxMantissa) {\\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\\n }\\n\\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\\n\\n (, actualAmountOut) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\\n\\n _doTransferOut(tokenAddressOut, to, actualAmountOut);\\n }\\n\\n /// @dev return actualAmountOut from reserves for tokenAddressOut\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param to Address of the tokenAddressOut receiver\\n /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred\\n /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n function _doTransferOut(\\n address tokenAddressOut,\\n address to,\\n uint256 amountConvertedMantissa\\n ) internal {\\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\\n\\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\\n if (maxTokenOutReserve < amountConvertedMantissa) {\\n revert InsufficientPoolLiquidity();\\n }\\n\\n _preTransferHook(tokenAddressOut, amountConvertedMantissa);\\n\\n IERC20Upgradeable tokenOut = IERC20Upgradeable(tokenAddressOut);\\n tokenOut.safeTransfer(to, amountConvertedMantissa);\\n }\\n\\n /// @notice Transfer tokenAddressIn from user to destination\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @return actualAmountIn Actual amount transferred to destination\\n function _doTransferIn(address tokenAddressIn, uint256 amountInMantissa) internal returns (uint256 actualAmountIn) {\\n IERC20Upgradeable tokenIn = IERC20Upgradeable(tokenAddressIn);\\n uint256 balanceBeforeDestination = tokenIn.balanceOf(destinationAddress);\\n tokenIn.safeTransferFrom(msg.sender, destinationAddress, amountInMantissa);\\n uint256 balanceAfterDestination = tokenIn.balanceOf(destinationAddress);\\n actualAmountIn = balanceAfterDestination - balanceBeforeDestination;\\n }\\n\\n /// @dev Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n /// @custom:event Emits PriceOracleUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero\\n function _setPriceOracle(ResilientOracle priceOracle_) internal {\\n ensureNonzeroAddress(address(priceOracle_));\\n emit PriceOracleUpdated(priceOracle, priceOracle_);\\n priceOracle = priceOracle_;\\n }\\n\\n /// @dev Sets a new destination address\\n /// @param destinationAddress_ The new destination address to be set\\n /// @custom:event Emits DestinationAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when destination address is zero\\n function _setDestination(address destinationAddress_) internal {\\n ensureNonzeroAddress(destinationAddress_);\\n emit DestinationAddressUpdated(destinationAddress, destinationAddress_);\\n destinationAddress = destinationAddress_;\\n }\\n\\n /// @notice Sets a converter network contract address\\n /// @param converterNetwork_ The converterNetwork address to be set\\n /// @custom:event Emits ConverterNetworkAddressUpdated event on success\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n function _setConverterNetwork(IConverterNetwork converterNetwork_) internal {\\n ensureNonzeroAddress(address(converterNetwork_));\\n emit ConverterNetworkAddressUpdated(address(converterNetwork), address(converterNetwork_));\\n converterNetwork = converterNetwork_;\\n }\\n\\n /// @notice Min amount to convert setter\\n /// @param minAmountToConvert_ Min amount to convert\\n /// @custom:event MinAmountToConvertUpdated is emitted in success\\n /// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\\n function _setMinAmountToConvert(uint256 minAmountToConvert_) internal {\\n ensureNonzeroValue(minAmountToConvert_);\\n emit MinAmountToConvertUpdated(minAmountToConvert, minAmountToConvert_);\\n minAmountToConvert = minAmountToConvert_;\\n }\\n\\n /// @dev Hook to perform after converting tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @param amountIn Amount of tokenIn converted\\n /// @param amountOut Amount of tokenOut converted\\n function _postConversionHook(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n uint256 amountIn,\\n uint256 amountOut\\n ) internal virtual {}\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n __AccessControlled_init(accessControlManager_);\\n __ReentrancyGuard_init();\\n __AbstractTokenConverter_init_unchained(priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param minAmountToConvert_ minimum amount to convert\\n function __AbstractTokenConverter_init_unchained(\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n uint256 minAmountToConvert_\\n ) internal onlyInitializing {\\n _setPriceOracle(priceOracle_);\\n _setDestination(destinationAddress_);\\n _setMinAmountToConvert(minAmountToConvert_);\\n conversionPaused = false;\\n }\\n\\n /// @dev _updateAssetsState hook to update the states of reserves transferred for the specific comptroller\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address\\n /// @return Amount of asset, for _privateConversion\\n function _updateAssetsState(address comptroller, address asset) internal virtual returns (uint256) {}\\n\\n /// @dev This method is used to convert asset into base asset by converting them with other converters which supports the pair and transfer the funds to\\n /// destination contract as destination's base asset\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset\\n /// @param amountToConvert Amount of the tokenAddressOut transferred to converter\\n function _privateConversion(\\n address comptroller,\\n address tokenAddressOut,\\n uint256 amountToConvert\\n ) internal {\\n address tokenAddressIn = _getDestinationBaseAsset();\\n address _destinationAddress = destinationAddress;\\n uint256 convertedTokenInBalance;\\n if (address(converterNetwork) != address(0)) {\\n (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork\\n .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn);\\n uint256 convertersLength = converterAddresses.length;\\n for (uint256 i; i < convertersLength; ) {\\n if (converterBalances[i] == 0) break;\\n (, uint256 amountIn) = IAbstractTokenConverter(converterAddresses[i]).getUpdatedAmountIn(\\n converterBalances[i],\\n tokenAddressOut,\\n tokenAddressIn\\n );\\n if (amountIn > amountToConvert) {\\n amountIn = amountToConvert;\\n }\\n\\n if (!_validateMinAmountToConvert(amountIn, tokenAddressOut)) {\\n break;\\n }\\n\\n uint256 balanceBefore = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n\\n IERC20Upgradeable(tokenAddressOut).forceApprove(converterAddresses[i], amountIn);\\n IAbstractTokenConverter(converterAddresses[i]).convertExactTokens(\\n amountIn,\\n 0,\\n tokenAddressOut,\\n tokenAddressIn,\\n _destinationAddress\\n );\\n\\n uint256 balanceAfter = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\\n amountToConvert -= amountIn;\\n convertedTokenInBalance += (balanceAfter - balanceBefore);\\n\\n if (amountToConvert == 0) break;\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n _postPrivateConversionHook(\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance,\\n tokenAddressOut,\\n amountToConvert\\n );\\n }\\n\\n /// @dev This hook is used to update states for the converter after the privateConversion\\n /// @param comptroller Comptroller address (pool)\\n /// @param tokenAddressIn Address of the destination's base asset\\n /// @param convertedTokenInBalance Amount of the base asset received after the conversion\\n /// @param tokenAddressOut Address of the asset transferred to other converter in exchange of base asset\\n /// @param convertedTokenOutBalance Amount of tokenAddressOut transferred from this converter\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address tokenAddressOut,\\n uint256 convertedTokenOutBalance\\n ) internal virtual {}\\n\\n /// @notice This hook is used to update the state for asset reserves before transferring tokenOut to user\\n /// @param tokenOutAddress Address of the asset to be transferred to the user\\n /// @param amountOut Amount of tokenAddressOut transferred from this converter\\n function _preTransferHook(address tokenOutAddress, uint256 amountOut) internal virtual {}\\n\\n /// @dev Checks if amount to convert is greater than minimum amount to convert or not\\n /// @param amountIn The amount to convert\\n /// @param tokenAddress Address of the token\\n /// @return isValid true if amount to convert is greater than minimum amount to convert\\n function _validateMinAmountToConvert(uint256 amountIn, address tokenAddress) internal returns (bool isValid) {\\n priceOracle.updateAssetPrice(tokenAddress);\\n uint256 amountInInUsd = (priceOracle.getPrice(tokenAddress) * amountIn) / EXP_SCALE;\\n\\n if (amountInInUsd >= minAmountToConvert) {\\n isValid = true;\\n }\\n }\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountOutMantissa, uint256 tokenInToOutConversion) {\\n if (amountInMantissa == 0) {\\n revert InsufficientInputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n if (address(converterNetwork) != address(0) && (converterNetwork.isTokenConverter(msg.sender))) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n /// amount of tokenAddressOut after including incentive as amountOutMantissa will be greater than actual as it gets\\n /// multiplied by conversionWithIncentive which will be >= 1\\n amountOutMantissa = (amountInMantissa * tokenInToOutConversion) / (EXP_SCALE);\\n }\\n\\n /// @dev To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @dev For user conversions, the function returns an amountInMantissa that is rounded up, ensuring that the equivalent amountInMantissa\\n /// is obtained from users for corresponding amountOutMantissa, preventing any losses to the protocol. However, no rounding up is required for private conversions\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function _getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) internal view returns (uint256 amountInMantissa, uint256 tokenInToOutConversion) {\\n if (amountOutMantissa == 0) {\\n revert InsufficientOutputAmount();\\n }\\n\\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\\n\\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\\n revert ConversionConfigNotEnabled();\\n }\\n\\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\\n\\n uint256 incentive = configuration.incentive;\\n\\n bool isPrivateConversion = address(converterNetwork) != address(0) &&\\n converterNetwork.isTokenConverter(msg.sender);\\n if (isPrivateConversion) {\\n incentive = 0;\\n }\\n\\n /// conversion rate after considering incentive(conversionWithIncentive)\\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\\n\\n /// amount of tokenAddressIn after considering incentive(i.e. amountInMantissa will be less than actual amountInMantissa if incentive > 0)\\n if (isPrivateConversion) {\\n amountInMantissa =\\n (amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE) /\\n (tokenInUnderlyingPrice * conversionWithIncentive);\\n } else {\\n amountInMantissa = _divRoundingUp(\\n amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE,\\n tokenInUnderlyingPrice * conversionWithIncentive\\n );\\n }\\n\\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\\n }\\n\\n /// @dev Check if msg.sender is allowed to convert as per onlyForPrivateConversions flag\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\\n function _checkPrivateConversion(address tokenAddressIn, address tokenAddressOut) internal view {\\n bool isConverter = (address(converterNetwork) != address(0)) && converterNetwork.isTokenConverter(msg.sender);\\n if (\\n (!(isConverter) &&\\n (conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\\n ConversionAccessibility.ONLY_FOR_CONVERTERS))\\n ) {\\n revert ConversionEnabledOnlyForPrivateConversions();\\n }\\n }\\n\\n /// @dev To check, is conversion paused\\n /// @custom:error ConversionTokensPaused is thrown when token conversion is paused\\n function _checkConversionPaused() internal view {\\n if (conversionPaused) {\\n revert ConversionTokensPaused();\\n }\\n }\\n\\n /// @dev Get base asset address of the destination contract\\n /// @return Address of the base asset\\n function _getDestinationBaseAsset() internal view virtual returns (address) {}\\n\\n /// @dev Performs division where the result is rounded up\\n /// @param numerator The numerator of the division operation\\n /// @param denominator The denominator of the division operation. Must be non-zero\\n /// @return The result of the division, rounded up\\n function _divRoundingUp(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\\n return (numerator + denominator - 1) / denominator;\\n }\\n}\\n\",\"keccak256\":\"0xf87680dcb5a46a16663923c575661eda78ef57d29b7d78a85ddac00062426e18\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/IAbstractTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity ^0.8.25;\\n\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { IConverterNetwork } from \\\"../Interfaces/IConverterNetwork.sol\\\";\\n\\n/// @notice Interface for AbstractTokenConverter\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ninterface IAbstractTokenConverter {\\n /// @notice This enum define the all possible ways of conversion can happen\\n enum ConversionAccessibility {\\n NONE, // Conversion is disable for the pair\\n ALL, // Conversion is enable for private conversion and users\\n ONLY_FOR_CONVERTERS, // Conversion is enable only for private conversion\\n ONLY_FOR_USERS // Conversion is enable only for users\\n }\\n\\n /// @notice This struct represents the configuration for a token conversion.\\n struct ConversionConfig {\\n /// incentive on conversion of tokens in mantissa i.e 10% incentive would be 0.1 * 1e18\\n uint256 incentive;\\n /// enable or disable conversion for users or converters or both or none\\n ConversionAccessibility conversionAccess;\\n }\\n\\n /// @notice Pause conversion of tokens\\n function pauseConversion() external;\\n\\n /// @notice Resume conversion of tokens.\\n function resumeConversion() external;\\n\\n /// @notice Sets a new price oracle\\n /// @param priceOracle_ Address of the new price oracle to set\\n function setPriceOracle(ResilientOracle priceOracle_) external;\\n\\n /// @notice Set the configuration for new or existing convert pair\\n /// @param tokenAddressIn Address of tokenIn\\n /// @param tokenAddressOut Address of tokenOut\\n /// @param conversionConfig ConversionConfig config details to update\\n function setConversionConfig(\\n address tokenAddressIn,\\n address tokenAddressOut,\\n ConversionConfig calldata conversionConfig\\n ) external;\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @dev Method does not support deflationary tokens transfer\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMantissa,\\n uint256 amountOutMinMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after convert\\n /// @param to Address of the tokenAddressOut receiver\\n function convertForExactTokensSupportingFeeOnTransferTokens(\\n uint256 amountInMaxMantissa,\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut,\\n address to\\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\\n\\n /// @notice Get the configuration for the pair of the tokens\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return incentives Percentage of incentives to be distributed for the pair of tokens\\n /// @return conversionAccess Accessibility for the pair of tokens\\n function conversionConfigurations(address tokenAddressIn, address tokenAddressOut)\\n external\\n returns (uint256 incentives, ConversionAccessibility conversionAccess);\\n\\n /// @notice Get the address of the converterNetwork\\n function converterNetwork() external returns (IConverterNetwork converterNetwork);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getUpdatedAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountIn(\\n uint256 amountOutMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\\n\\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\\n /// @dev This function retrieves values without altering token prices.\\n /// @param amountInMantissa Amount of tokenAddressIn\\n /// @param tokenAddressIn Address of the token to convert\\n /// @param tokenAddressOut Address of the token to get after conversion\\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\\n function getAmountOut(\\n uint256 amountInMantissa,\\n address tokenAddressIn,\\n address tokenAddressOut\\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\\n\\n /// @notice Get the balance for specific token\\n /// @param token Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address token) external view returns (uint256 tokenBalance);\\n}\\n\",\"keccak256\":\"0x7852d4f8a6dd1c80d14342f8ff2e26f723eb00c888e9a9e50a5fe8f95c59200c\",\"license\":\"BSD-3-Clause\"},\"contracts/TokenConverter/SingleTokenConverter.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-3-Clause\\npragma solidity 0.8.25;\\n\\nimport { SafeERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\\\";\\nimport { IERC20Upgradeable } from \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport { ResilientOracle } from \\\"@venusprotocol/oracle/contracts/ResilientOracle.sol\\\";\\nimport { ensureNonzeroAddress } from \\\"@venusprotocol/solidity-utilities/contracts/validators.sol\\\";\\n\\nimport { AbstractTokenConverter } from \\\"./AbstractTokenConverter.sol\\\";\\n\\n/// @title SingleTokenConverter\\n/// @author Venus\\n/// @notice SingleTokenConverter used for token conversions and sends received tokens\\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\\ncontract SingleTokenConverter is AbstractTokenConverter {\\n using SafeERC20Upgradeable for IERC20Upgradeable;\\n\\n /// @notice Address of the base asset token\\n address public baseAsset;\\n\\n /// @notice The mapping contains the assets which are sent to destination directly\\n /// @dev Asset -> bool(should transfer directly on true)\\n mapping(address => bool) public assetsDirectTransfer;\\n\\n /// @notice Emitted when base asset is updated\\n event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset);\\n\\n /// @notice Emmitted after the funds transferred to the destination address\\n event AssetTransferredToDestination(\\n address indexed receiver,\\n address indexed comptroller,\\n address indexed asset,\\n uint256 amount\\n );\\n\\n /// @notice Emitted after the assetsDirectTransfer mapping is updated\\n event AssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value);\\n\\n /// @notice Thrown when the base asset is the same as the new base asset\\n error SameBaseAssetNotAllowed();\\n\\n /// @notice Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection\\n error DirectTransferBaseAssetNotAllowed();\\n\\n /// @notice Thrown when the `assetsDirectTransfer[asset]` is already `value`\\n /// @param asset The asset address whose `assetDirectTransfer` value went to be set\\n /// @param value The value to be set\\n error SameAssetDirectTransferNotAllowed(address asset, bool value);\\n\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor() {\\n // Note that the contract is upgradeable. Use initialize() or reinitializers\\n // to set the state variables.\\n _disableInitializers();\\n }\\n\\n /// @param accessControlManager_ Access control manager contract address\\n /// @param priceOracle_ Resilient oracle address\\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\\n /// @param baseAsset_ Address of the base asset\\n /// @param minAmountToConvert_ Minimum amount to convert\\n function initialize(\\n address accessControlManager_,\\n ResilientOracle priceOracle_,\\n address destinationAddress_,\\n address baseAsset_,\\n uint256 minAmountToConvert_\\n ) public initializer {\\n _setBaseAsset(baseAsset_);\\n\\n // Initialize AbstractTokenConverter\\n __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);\\n }\\n\\n /// @notice Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\\n /// @custom:event BaseAssetUpdated is emitted on success\\n /// @custom:access Only Governance\\n function setBaseAsset(address baseAsset_) external onlyOwner {\\n _setBaseAsset(baseAsset_);\\n }\\n\\n /// @notice Update the assetsDirectTransfer mapping\\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\\n /// @custom:event AssetsDirectTransferUpdated emits on success\\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\\n /// @custom:access Restricted by ACM\\n function setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) external virtual {\\n _checkAccessAllowed(\\\"setAssetsDirectTransfer(address[],bool[])\\\");\\n _setAssetsDirectTransfer(assets, values);\\n }\\n\\n /// @notice Get the balance for specific token\\n /// @param tokenAddress Address of the token\\n /// @return tokenBalance Balance of the token the contract has\\n function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {\\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\\n tokenBalance = token.balanceOf(address(this));\\n }\\n\\n /// @dev It returns the balance of the `asset` in this contract. If `asset` is the `baseAsset`\\n /// or `assetsDirectTransfer[asset]` is true, then the balance of `asset` in this contract will\\n /// be transferred to the `destinationAddress` and 0 will be returned\\n /// @param comptroller Comptroller address (pool)\\n /// @param asset Asset address.\\n /// @return balanceLeft Amount of asset, for _privateConversion\\n function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) {\\n IERC20Upgradeable token = IERC20Upgradeable(asset);\\n uint256 balance = token.balanceOf(address(this));\\n balanceLeft = balance;\\n\\n if (asset == baseAsset || assetsDirectTransfer[asset]) {\\n balanceLeft = 0;\\n token.safeTransfer(destinationAddress, balance);\\n emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance);\\n }\\n }\\n\\n /// @notice Hook called after a private conversion is completed\\n /// @dev Emits an AssetTransferredToDestination event if Private Conversion happens\\n /// @param comptroller The address of the comptroller (pool) associated with the conversion\\n /// @param tokenAddressIn The address of the input token that was converted\\n /// @param convertedTokenInBalance The amount of input token that was converted\\n /// @custom:event AssetTransferredToDestination Emitted when convertedTokenInBalance > 0, indicating\\n /// the converted assets were transferred to the destination address\\n function _postPrivateConversionHook(\\n address comptroller,\\n address tokenAddressIn,\\n uint256 convertedTokenInBalance,\\n address,\\n uint256\\n ) internal override {\\n if (convertedTokenInBalance > 0) {\\n emit AssetTransferredToDestination(\\n destinationAddress,\\n comptroller,\\n tokenAddressIn,\\n convertedTokenInBalance\\n );\\n }\\n }\\n\\n /// @dev Update the assetsDirectTransfer mapping for destinationAddress\\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\\n /// @custom:event AssetsDirectTransferUpdated emits on success\\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\\n /// @custom:error DirectTransferBaseAssetNotAllowed thrown when an asset in `assets` is the `baseAsset`\\n /// @custom:error SameAssetDirectTransferNotAllowed thrown when the value to set for an asset doesn't differs\\n /// from its current value\\n function _setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) internal {\\n uint256 assetsLength = assets.length;\\n\\n if (assetsLength != values.length) {\\n revert InputLengthMisMatch();\\n }\\n\\n for (uint256 i; i < assetsLength; ++i) {\\n if (assets[i] == baseAsset) {\\n revert DirectTransferBaseAssetNotAllowed();\\n }\\n\\n if (assetsDirectTransfer[assets[i]] == values[i]) {\\n revert SameAssetDirectTransferNotAllowed(assets[i], values[i]);\\n }\\n\\n assetsDirectTransfer[assets[i]] = values[i];\\n emit AssetsDirectTransferUpdated(destinationAddress, assets[i], values[i]);\\n }\\n }\\n\\n /// @dev Sets the base asset for the contract\\n /// @param baseAsset_ The new address of the base asset\\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\\n /// @custom:event BaseAssetUpdated is emitted on success\\n function _setBaseAsset(address baseAsset_) internal {\\n ensureNonzeroAddress(baseAsset_);\\n\\n if (baseAsset == baseAsset_) {\\n revert SameBaseAssetNotAllowed();\\n }\\n\\n emit BaseAssetUpdated(baseAsset, baseAsset_);\\n baseAsset = baseAsset_;\\n }\\n\\n /// @dev Get base asset address\\n /// @return destinationBaseAsset Address of the base asset(baseAsset)\\n function _getDestinationBaseAsset() internal view override returns (address destinationBaseAsset) {\\n destinationBaseAsset = baseAsset;\\n }\\n}\\n\",\"keccak256\":\"0x3358796675c9c556ce90143ed762f7f2ed3ce46a5faeaf3d99574b0ba134cfac\",\"license\":\"BSD-3-Clause\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", "devdoc": { "author": "Venus", "custom:security-contact": "https://github.com/VenusProtocol/protocol-reserve#discussion", + "errors": { + "SameAssetDirectTransferNotAllowed(address,bool)": [ + { + "params": { + "asset": "The asset address whose `assetDirectTransfer` value went to be set", + "value": "The value to be set" + } + } + ] + }, "events": { "Initialized(uint8)": { "details": "Triggered when the contract has been initialized or reinitialized." @@ -1586,8 +1684,19 @@ "accessControlManager_": "The new address of the AccessControlManager" } }, + "setAssetsDirectTransfer(address[],bool[])": { + "custom:access": "Restricted by ACM", + "custom:error": "InputLengthMisMatch thrown when assets and values array lengths don't match", + "custom:event": "AssetsDirectTransferUpdated emits on success", + "params": { + "assets": "Addresses of the assets need to be added or removed for direct transfer", + "values": "Boolean value to indicate whether direct transfer is allowed for each asset." + } + }, "setBaseAsset(address)": { "custom:access": "Only Governance", + "custom:error": "ZeroAddressNotAllowed is thrown when address is zeroSameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset", + "custom:event": "BaseAssetUpdated is emitted on success", "params": { "baseAsset_": "The new address of the base asset" } @@ -1655,6 +1764,11 @@ } } }, + "stateVariables": { + "assetsDirectTransfer": { + "details": "Asset -> bool(should transfer directly on true)" + } + }, "title": "SingleTokenConverter", "version": 1 }, @@ -1705,6 +1819,11 @@ "notice": "Thrown when using convertForExactTokens deflationary tokens" } ], + "DirectTransferBaseAssetNotAllowed()": [ + { + "notice": "Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection" + } + ], "IncentiveTooHigh(uint256,uint256)": [ { "notice": "Thrown when incentive is higher than the MAX_INCENTIVE" @@ -1755,6 +1874,16 @@ "notice": "Thrown when trying to set non zero incentive for private conversion" } ], + "SameAssetDirectTransferNotAllowed(address,bool)": [ + { + "notice": "Thrown when the `assetsDirectTransfer[asset]` is already `value`" + } + ], + "SameBaseAssetNotAllowed()": [ + { + "notice": "Thrown when the base asset is the same as the new base asset" + } + ], "Unauthorized(address,address,string)": [ { "notice": "Thrown when the action is prohibited by AccessControlManager" @@ -1775,6 +1904,9 @@ "AssetTransferredToDestination(address,address,address,uint256)": { "notice": "Emmitted after the funds transferred to the destination address" }, + "AssetsDirectTransferUpdated(address,address,bool)": { + "notice": "Emitted after the assetsDirectTransfer mapping is updated" + }, "BaseAssetUpdated(address,address)": { "notice": "Emitted when base asset is updated" }, @@ -1826,6 +1958,9 @@ "accessControlManager()": { "notice": "Returns the address of the access control manager contract" }, + "assetsDirectTransfer(address)": { + "notice": "The mapping contains the assets which are sent to destination directly" + }, "balanceOf(address)": { "notice": "Get the balance for specific token" }, @@ -1883,6 +2018,9 @@ "setAccessControlManager(address)": { "notice": "Sets the address of AccessControlManager" }, + "setAssetsDirectTransfer(address[],bool[])": { + "notice": "Update the assetsDirectTransfer mapping" + }, "setBaseAsset(address)": { "notice": "Sets the base asset for the contract" }, @@ -2067,6 +2205,14 @@ "offset": 0, "slot": "301", "type": "t_address" + }, + { + "astId": 5318, + "contract": "contracts/TokenConverter/SingleTokenConverter.sol:SingleTokenConverter", + "label": "assetsDirectTransfer", + "offset": 0, + "slot": "302", + "type": "t_mapping(t_address,t_bool)" } ], "types": { @@ -2118,6 +2264,13 @@ "label": "enum IAbstractTokenConverter.ConversionAccessibility", "numberOfBytes": "1" }, + "t_mapping(t_address,t_bool)": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => bool)", + "numberOfBytes": "32", + "value": "t_bool" + }, "t_mapping(t_address,t_mapping(t_address,t_struct(ConversionConfig)5108_storage))": { "encoding": "mapping", "key": "t_address", diff --git a/deployments/bsctestnet/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json b/deployments/bsctestnet/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json new file mode 100644 index 00000000..774cd037 --- /dev/null +++ b/deployments/bsctestnet/solcInputs/dceb6d0de70f90933a7f2cdf26a987ca.json @@ -0,0 +1,103 @@ +{ + "language": "Solidity", + "sources": { + "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./OwnableUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\n function __Ownable2Step_init() internal onlyInitializing {\n __Ownable_init_unchained();\n }\n\n function __Ownable2Step_init_unchained() internal onlyInitializing {\n }\n address private _pendingOwner;\n\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Returns the address of the pending owner.\n */\n function pendingOwner() public view virtual returns (address) {\n return _pendingOwner;\n }\n\n /**\n * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual override onlyOwner {\n _pendingOwner = newOwner;\n emit OwnershipTransferStarted(owner(), newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual override {\n delete _pendingOwner;\n super._transferOwnership(newOwner);\n }\n\n /**\n * @dev The new owner accepts the ownership transfer.\n */\n function acceptOwnership() public virtual {\n address sender = _msgSender();\n require(pendingOwner() == sender, \"Ownable2Step: caller is not the new owner\");\n _transferOwnership(sender);\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n function __Ownable_init() internal onlyInitializing {\n __Ownable_init_unchained();\n }\n\n function __Ownable_init_unchained() internal onlyInitializing {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if the sender is not the owner.\n */\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby disabling any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n */\n uint8 private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint8 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts.\n *\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n * constructor.\n *\n * Emits an {Initialized} event.\n */\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n * are added through upgrades and that require initialization.\n *\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n * cannot be nested. If one is invoked in the context of another, execution will revert.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n *\n * WARNING: setting the version to 255 will prevent any future reinitialization.\n *\n * Emits an {Initialized} event.\n */\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n *\n * Emits an {Initialized} event the first time it is successfully executed.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized != type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n\n /**\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\n */\n function _getInitializedVersion() internal view returns (uint8) {\n return _initialized;\n }\n\n /**\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n */\n function _isInitializing() internal view returns (bool) {\n return _initializing;\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n /**\n * @dev Emitted when the pause is triggered by `account`.\n */\n event Paused(address account);\n\n /**\n * @dev Emitted when the pause is lifted by `account`.\n */\n event Unpaused(address account);\n\n bool private _paused;\n\n /**\n * @dev Initializes the contract in unpaused state.\n */\n function __Pausable_init() internal onlyInitializing {\n __Pausable_init_unchained();\n }\n\n function __Pausable_init_unchained() internal onlyInitializing {\n _paused = false;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is not paused.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n modifier whenNotPaused() {\n _requireNotPaused();\n _;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is paused.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n modifier whenPaused() {\n _requirePaused();\n _;\n }\n\n /**\n * @dev Returns true if the contract is paused, and false otherwise.\n */\n function paused() public view virtual returns (bool) {\n return _paused;\n }\n\n /**\n * @dev Throws if the contract is paused.\n */\n function _requireNotPaused() internal view virtual {\n require(!paused(), \"Pausable: paused\");\n }\n\n /**\n * @dev Throws if the contract is not paused.\n */\n function _requirePaused() internal view virtual {\n require(paused(), \"Pausable: not paused\");\n }\n\n /**\n * @dev Triggers stopped state.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n function _pause() internal virtual whenNotPaused {\n _paused = true;\n emit Paused(_msgSender());\n }\n\n /**\n * @dev Returns to normal state.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n function _unpause() internal virtual whenPaused {\n _paused = false;\n emit Unpaused(_msgSender());\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuardUpgradeable is Initializable {\n // Booleans are more expensive than uint256 or any type that takes up a full\n // word because each write operation emits an extra SLOAD to first read the\n // slot's contents, replace the bits taken up by the boolean, and then write\n // back. This is the compiler's defense against contract upgrades and\n // pointer aliasing, and it cannot be disabled.\n\n // The values being non-zero value makes deployment a bit more expensive,\n // but in exchange the refund on every call to nonReentrant will be lower in\n // amount. Since refunds are capped to a percentage of the total\n // transaction's gas, it is best to keep them low in cases like this one, to\n // increase the likelihood of the full refund coming into effect.\n uint256 private constant _NOT_ENTERED = 1;\n uint256 private constant _ENTERED = 2;\n\n uint256 private _status;\n\n function __ReentrancyGuard_init() internal onlyInitializing {\n __ReentrancyGuard_init_unchained();\n }\n\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\n _status = _NOT_ENTERED;\n }\n\n /**\n * @dev Prevents a contract from calling itself, directly or indirectly.\n * Calling a `nonReentrant` function from another `nonReentrant`\n * function is not supported. It is possible to prevent this from happening\n * by making the `nonReentrant` function external, and making it call a\n * `private` function that does the actual work.\n */\n modifier nonReentrant() {\n _nonReentrantBefore();\n _;\n _nonReentrantAfter();\n }\n\n function _nonReentrantBefore() private {\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\n require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n // Any calls to nonReentrant after this point will fail\n _status = _ENTERED;\n }\n\n function _nonReentrantAfter() private {\n // By storing the original value once again, a refund is triggered (see\n // https://eips.ethereum.org/EIPS/eip-2200)\n _status = _NOT_ENTERED;\n }\n\n /**\n * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n * `nonReentrant` function in the call stack.\n */\n function _reentrancyGuardEntered() internal view returns (bool) {\n return _status == _ENTERED;\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20PermitUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20PermitUpgradeable {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n" + }, + "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\nimport \"../extensions/IERC20PermitUpgradeable.sol\";\nimport \"../../../utils/AddressUpgradeable.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20Upgradeable {\n using AddressUpgradeable for address;\n\n /**\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n /**\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n */\n function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n require(\n (value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n /**\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n uint256 oldAllowance = token.allowance(address(this), spender);\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\n }\n\n /**\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\n }\n }\n\n /**\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n * to be set to zero before setting it to a non-zero value, such as USDT.\n */\n function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\n\n if (!_callOptionalReturnBool(token, approvalCall)) {\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\n _callOptionalReturn(token, approvalCall);\n }\n }\n\n /**\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\n * Revert on invalid signature.\n */\n function safePermit(\n IERC20PermitUpgradeable token,\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal {\n uint256 nonceBefore = token.nonces(owner);\n token.permit(owner, spender, value, deadline, v, r, s);\n uint256 nonceAfter = token.nonces(owner);\n require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n *\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n */\n function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n // and not revert is the subcall reverts.\n\n (bool success, bytes memory returndata) = address(token).call(data);\n return\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n *\n * Furthermore, `isContract` will also return true if the target contract within\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n * which only has an effect at the end of a transaction.\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n *\n * _Available since v4.8._\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n if (success) {\n if (returndata.length == 0) {\n // only check isContract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n require(isContract(target), \"Address: call to non-contract\");\n }\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason or using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n" + }, + "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n function __Context_init() internal onlyInitializing {\n }\n\n function __Context_init_unchained() internal onlyInitializing {\n }\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n" + }, + "@openzeppelin/contracts/access/IAccessControl.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n *\n * _Available since v3.1._\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {AccessControl-_setupRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) external view returns (bool);\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `account`.\n */\n function renounceRole(bytes32 role, address account) external;\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/IERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n" + }, + "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\";\n\nimport \"./IAccessControlManagerV8.sol\";\n\n/**\n * @title AccessControlledV8\n * @author Venus\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.8.13)\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\n */\nabstract contract AccessControlledV8 is Initializable, Ownable2StepUpgradeable {\n /// @notice Access control manager contract\n IAccessControlManagerV8 private _accessControlManager;\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n\n /// @notice Emitted when access control manager contract address is changed\n event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\n\n /// @notice Thrown when the action is prohibited by AccessControlManager\n error Unauthorized(address sender, address calledContract, string methodSignature);\n\n function __AccessControlled_init(address accessControlManager_) internal onlyInitializing {\n __Ownable2Step_init();\n __AccessControlled_init_unchained(accessControlManager_);\n }\n\n function __AccessControlled_init_unchained(address accessControlManager_) internal onlyInitializing {\n _setAccessControlManager(accessControlManager_);\n }\n\n /**\n * @notice Sets the address of AccessControlManager\n * @dev Admin function to set address of AccessControlManager\n * @param accessControlManager_ The new address of the AccessControlManager\n * @custom:event Emits NewAccessControlManager event\n * @custom:access Only Governance\n */\n function setAccessControlManager(address accessControlManager_) external onlyOwner {\n _setAccessControlManager(accessControlManager_);\n }\n\n /**\n * @notice Returns the address of the access control manager contract\n */\n function accessControlManager() external view returns (IAccessControlManagerV8) {\n return _accessControlManager;\n }\n\n /**\n * @dev Internal function to set address of AccessControlManager\n * @param accessControlManager_ The new address of the AccessControlManager\n */\n function _setAccessControlManager(address accessControlManager_) internal {\n require(address(accessControlManager_) != address(0), \"invalid acess control manager address\");\n address oldAccessControlManager = address(_accessControlManager);\n _accessControlManager = IAccessControlManagerV8(accessControlManager_);\n emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\n }\n\n /**\n * @notice Reverts if the call is not allowed by AccessControlManager\n * @param signature Method signature\n */\n function _checkAccessAllowed(string memory signature) internal view {\n bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\n\n if (!isAllowedToCall) {\n revert Unauthorized(msg.sender, address(this), signature);\n }\n }\n}\n" + }, + "@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport \"@openzeppelin/contracts/access/IAccessControl.sol\";\n\n/**\n * @title IAccessControlManagerV8\n * @author Venus\n * @notice Interface implemented by the `AccessControlManagerV8` contract.\n */\ninterface IAccessControlManagerV8 is IAccessControl {\n function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\n\n function revokeCallPermission(\n address contractAddress,\n string calldata functionSig,\n address accountToRevoke\n ) external;\n\n function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\n\n function hasPermission(\n address account,\n address contractAddress,\n string calldata functionSig\n ) external view returns (bool);\n}\n" + }, + "@venusprotocol/oracle/contracts/interfaces/OracleInterface.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\ninterface OracleInterface {\n function getPrice(address asset) external view returns (uint256);\n}\n\ninterface ResilientOracleInterface is OracleInterface {\n function updatePrice(address vToken) external;\n\n function updateAssetPrice(address asset) external;\n\n function getUnderlyingPrice(address vToken) external view returns (uint256);\n}\n\ninterface TwapInterface is OracleInterface {\n function updateTwap(address asset) external returns (uint256);\n}\n\ninterface BoundValidatorInterface {\n function validatePriceWithAnchorPrice(\n address asset,\n uint256 reporterPrice,\n uint256 anchorPrice\n ) external view returns (bool);\n}\n" + }, + "@venusprotocol/oracle/contracts/interfaces/VBep20Interface.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface VBep20Interface is IERC20Metadata {\n /**\n * @notice Underlying asset for this VToken\n */\n function underlying() external view returns (address);\n}\n" + }, + "@venusprotocol/oracle/contracts/ResilientOracle.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\n// SPDX-FileCopyrightText: 2022 Venus\npragma solidity 0.8.25;\n\nimport \"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\";\nimport \"./interfaces/VBep20Interface.sol\";\nimport \"./interfaces/OracleInterface.sol\";\nimport \"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\";\n\n/**\n * @title ResilientOracle\n * @author Venus\n * @notice The Resilient Oracle is the main contract that the protocol uses to fetch prices of assets.\n *\n * DeFi protocols are vulnerable to price oracle failures including oracle manipulation and incorrectly\n * reported prices. If only one oracle is used, this creates a single point of failure and opens a vector\n * for attacking the protocol.\n *\n * The Resilient Oracle uses multiple sources and fallback mechanisms to provide accurate prices and protect\n * the protocol from oracle attacks. Currently it includes integrations with Chainlink, Pyth, Binance Oracle\n * and TWAP (Time-Weighted Average Price) oracles. TWAP uses PancakeSwap as the on-chain price source.\n *\n * For every market (vToken) we configure the main, pivot and fallback oracles. The oracles are configured per\n * vToken's underlying asset address. The main oracle oracle is the most trustworthy price source, the pivot\n * oracle is used as a loose sanity checker and the fallback oracle is used as a backup price source.\n *\n * To validate prices returned from two oracles, we use an upper and lower bound ratio that is set for every\n * market. The upper bound ratio represents the deviation between reported price (the price that’s being\n * validated) and the anchor price (the price we are validating against) above which the reported price will\n * be invalidated. The lower bound ratio presents the deviation between reported price and anchor price below\n * which the reported price will be invalidated. So for oracle price to be considered valid the below statement\n * should be true:\n\n```\nanchorRatio = anchorPrice/reporterPrice\nisValid = anchorRatio <= upperBoundAnchorRatio && anchorRatio >= lowerBoundAnchorRatio\n```\n\n * In most cases, Chainlink is used as the main oracle, TWAP or Pyth oracles are used as the pivot oracle depending\n * on which supports the given market and Binance oracle is used as the fallback oracle. For some markets we may\n * use Pyth or TWAP as the main oracle if the token price is not supported by Chainlink or Binance oracles.\n *\n * For a fetched price to be valid it must be positive and not stagnant. If the price is invalid then we consider the\n * oracle to be stagnant and treat it like it's disabled.\n */\ncontract ResilientOracle is PausableUpgradeable, AccessControlledV8, ResilientOracleInterface {\n /**\n * @dev Oracle roles:\n * **main**: The most trustworthy price source\n * **pivot**: Price oracle used as a loose sanity checker\n * **fallback**: The backup source when main oracle price is invalidated\n */\n enum OracleRole {\n MAIN,\n PIVOT,\n FALLBACK\n }\n\n struct TokenConfig {\n /// @notice asset address\n address asset;\n /// @notice `oracles` stores the oracles based on their role in the following order:\n /// [main, pivot, fallback],\n /// It can be indexed with the corresponding enum OracleRole value\n address[3] oracles;\n /// @notice `enableFlagsForOracles` stores the enabled state\n /// for each oracle in the same order as `oracles`\n bool[3] enableFlagsForOracles;\n }\n\n uint256 public constant INVALID_PRICE = 0;\n\n /// @notice Native market address\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n address public immutable nativeMarket;\n\n /// @notice VAI address\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n address public immutable vai;\n\n /// @notice Set this as asset address for Native token on each chain.This is the underlying for vBNB (on bsc)\n /// and can serve as any underlying asset of a market that supports native tokens\n address public constant NATIVE_TOKEN_ADDR = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\n\n /// @notice Bound validator contract address\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n BoundValidatorInterface public immutable boundValidator;\n\n mapping(address => TokenConfig) private tokenConfigs;\n\n event TokenConfigAdded(\n address indexed asset,\n address indexed mainOracle,\n address indexed pivotOracle,\n address fallbackOracle\n );\n\n /// Event emitted when an oracle is set\n event OracleSet(address indexed asset, address indexed oracle, uint256 indexed role);\n\n /// Event emitted when an oracle is enabled or disabled\n event OracleEnabled(address indexed asset, uint256 indexed role, bool indexed enable);\n\n /**\n * @notice Checks whether an address is null or not\n */\n modifier notNullAddress(address someone) {\n if (someone == address(0)) revert(\"can't be zero address\");\n _;\n }\n\n /**\n * @notice Checks whether token config exists by checking whether asset is null address\n * @dev address can't be null, so it's suitable to be used to check the validity of the config\n * @param asset asset address\n */\n modifier checkTokenConfigExistence(address asset) {\n if (tokenConfigs[asset].asset == address(0)) revert(\"token config must exist\");\n _;\n }\n\n /// @notice Constructor for the implementation contract. Sets immutable variables.\n /// @dev nativeMarketAddress can be address(0) if on the chain we do not support native market\n /// (e.g vETH on ethereum would not be supported, only vWETH)\n /// @param nativeMarketAddress The address of a native market (for bsc it would be vBNB address)\n /// @param vaiAddress The address of the VAI token (if there is VAI on the deployed chain).\n /// Set to address(0) of VAI is not existent.\n /// @param _boundValidator Address of the bound validator contract\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor(\n address nativeMarketAddress,\n address vaiAddress,\n BoundValidatorInterface _boundValidator\n ) notNullAddress(address(_boundValidator)) {\n nativeMarket = nativeMarketAddress;\n vai = vaiAddress;\n boundValidator = _boundValidator;\n\n _disableInitializers();\n }\n\n /**\n * @notice Initializes the contract admin and sets the BoundValidator contract address\n * @param accessControlManager_ Address of the access control manager contract\n */\n function initialize(address accessControlManager_) external initializer {\n __AccessControlled_init(accessControlManager_);\n __Pausable_init();\n }\n\n /**\n * @notice Pauses oracle\n * @custom:access Only Governance\n */\n function pause() external {\n _checkAccessAllowed(\"pause()\");\n _pause();\n }\n\n /**\n * @notice Unpauses oracle\n * @custom:access Only Governance\n */\n function unpause() external {\n _checkAccessAllowed(\"unpause()\");\n _unpause();\n }\n\n /**\n * @notice Batch sets token configs\n * @param tokenConfigs_ Token config array\n * @custom:access Only Governance\n * @custom:error Throws a length error if the length of the token configs array is 0\n */\n function setTokenConfigs(TokenConfig[] memory tokenConfigs_) external {\n if (tokenConfigs_.length == 0) revert(\"length can't be 0\");\n uint256 numTokenConfigs = tokenConfigs_.length;\n for (uint256 i; i < numTokenConfigs; ) {\n setTokenConfig(tokenConfigs_[i]);\n unchecked {\n ++i;\n }\n }\n }\n\n /**\n * @notice Sets oracle for a given asset and role.\n * @dev Supplied asset **must** exist and main oracle may not be null\n * @param asset Asset address\n * @param oracle Oracle address\n * @param role Oracle role\n * @custom:access Only Governance\n * @custom:error Null address error if main-role oracle address is null\n * @custom:error NotNullAddress error is thrown if asset address is null\n * @custom:error TokenConfigExistance error is thrown if token config is not set\n * @custom:event Emits OracleSet event with asset address, oracle address and role of the oracle for the asset\n */\n function setOracle(\n address asset,\n address oracle,\n OracleRole role\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\n _checkAccessAllowed(\"setOracle(address,address,uint8)\");\n if (oracle == address(0) && role == OracleRole.MAIN) revert(\"can't set zero address to main oracle\");\n tokenConfigs[asset].oracles[uint256(role)] = oracle;\n emit OracleSet(asset, oracle, uint256(role));\n }\n\n /**\n * @notice Enables/ disables oracle for the input asset. Token config for the input asset **must** exist\n * @dev Configuration for the asset **must** already exist and the asset cannot be 0 address\n * @param asset Asset address\n * @param role Oracle role\n * @param enable Enabled boolean of the oracle\n * @custom:access Only Governance\n * @custom:error NotNullAddress error is thrown if asset address is null\n * @custom:error TokenConfigExistance error is thrown if token config is not set\n */\n function enableOracle(\n address asset,\n OracleRole role,\n bool enable\n ) external notNullAddress(asset) checkTokenConfigExistence(asset) {\n _checkAccessAllowed(\"enableOracle(address,uint8,bool)\");\n tokenConfigs[asset].enableFlagsForOracles[uint256(role)] = enable;\n emit OracleEnabled(asset, uint256(role), enable);\n }\n\n /**\n * @notice Updates the TWAP pivot oracle price.\n * @dev This function should always be called before calling getUnderlyingPrice\n * @param vToken vToken address\n */\n function updatePrice(address vToken) external override {\n address asset = _getUnderlyingAsset(vToken);\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\n if (pivotOracle != address(0) && pivotOracleEnabled) {\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\n }\n }\n\n /**\n * @notice Updates the pivot oracle price. Currently using TWAP\n * @dev This function should always be called before calling getPrice\n * @param asset asset address\n */\n function updateAssetPrice(address asset) external {\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\n if (pivotOracle != address(0) && pivotOracleEnabled) {\n //if pivot oracle is not TwapOracle it will revert so we need to catch the revert\n try TwapInterface(pivotOracle).updateTwap(asset) {} catch {}\n }\n }\n\n /**\n * @dev Gets token config by asset address\n * @param asset asset address\n * @return tokenConfig Config for the asset\n */\n function getTokenConfig(address asset) external view returns (TokenConfig memory) {\n return tokenConfigs[asset];\n }\n\n /**\n * @notice Gets price of the underlying asset for a given vToken. Validation flow:\n * - Check if the oracle is paused globally\n * - Validate price from main oracle against pivot oracle\n * - Validate price from fallback oracle against pivot oracle if the first validation failed\n * - Validate price from main oracle against fallback oracle if the second validation failed\n * In the case that the pivot oracle is not available but main price is available and validation is successful,\n * main oracle price is returned.\n * @param vToken vToken address\n * @return price USD price in scaled decimal places.\n * @custom:error Paused error is thrown when resilent oracle is paused\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\n */\n function getUnderlyingPrice(address vToken) external view override returns (uint256) {\n if (paused()) revert(\"resilient oracle is paused\");\n\n address asset = _getUnderlyingAsset(vToken);\n return _getPrice(asset);\n }\n\n /**\n * @notice Gets price of the asset\n * @param asset asset address\n * @return price USD price in scaled decimal places.\n * @custom:error Paused error is thrown when resilent oracle is paused\n * @custom:error Invalid resilient oracle price error is thrown if fetched prices from oracle is invalid\n */\n function getPrice(address asset) external view override returns (uint256) {\n if (paused()) revert(\"resilient oracle is paused\");\n return _getPrice(asset);\n }\n\n /**\n * @notice Sets/resets single token configs.\n * @dev main oracle **must not** be a null address\n * @param tokenConfig Token config struct\n * @custom:access Only Governance\n * @custom:error NotNullAddress is thrown if asset address is null\n * @custom:error NotNullAddress is thrown if main-role oracle address for asset is null\n * @custom:event Emits TokenConfigAdded event when the asset config is set successfully by the authorized account\n */\n function setTokenConfig(\n TokenConfig memory tokenConfig\n ) public notNullAddress(tokenConfig.asset) notNullAddress(tokenConfig.oracles[uint256(OracleRole.MAIN)]) {\n _checkAccessAllowed(\"setTokenConfig(TokenConfig)\");\n\n tokenConfigs[tokenConfig.asset] = tokenConfig;\n emit TokenConfigAdded(\n tokenConfig.asset,\n tokenConfig.oracles[uint256(OracleRole.MAIN)],\n tokenConfig.oracles[uint256(OracleRole.PIVOT)],\n tokenConfig.oracles[uint256(OracleRole.FALLBACK)]\n );\n }\n\n /**\n * @notice Gets oracle and enabled status by asset address\n * @param asset asset address\n * @param role Oracle role\n * @return oracle Oracle address based on role\n * @return enabled Enabled flag of the oracle based on token config\n */\n function getOracle(address asset, OracleRole role) public view returns (address oracle, bool enabled) {\n oracle = tokenConfigs[asset].oracles[uint256(role)];\n enabled = tokenConfigs[asset].enableFlagsForOracles[uint256(role)];\n }\n\n function _getPrice(address asset) internal view returns (uint256) {\n uint256 pivotPrice = INVALID_PRICE;\n\n // Get pivot oracle price, Invalid price if not available or error\n (address pivotOracle, bool pivotOracleEnabled) = getOracle(asset, OracleRole.PIVOT);\n if (pivotOracleEnabled && pivotOracle != address(0)) {\n try OracleInterface(pivotOracle).getPrice(asset) returns (uint256 pricePivot) {\n pivotPrice = pricePivot;\n } catch {}\n }\n\n // Compare main price and pivot price, return main price and if validation was successful\n // note: In case pivot oracle is not available but main price is available and\n // validation is successful, the main oracle price is returned.\n (uint256 mainPrice, bool validatedPivotMain) = _getMainOraclePrice(\n asset,\n pivotPrice,\n pivotOracleEnabled && pivotOracle != address(0)\n );\n if (mainPrice != INVALID_PRICE && validatedPivotMain) return mainPrice;\n\n // Compare fallback and pivot if main oracle comparision fails with pivot\n // Return fallback price when fallback price is validated successfully with pivot oracle\n (uint256 fallbackPrice, bool validatedPivotFallback) = _getFallbackOraclePrice(asset, pivotPrice);\n if (fallbackPrice != INVALID_PRICE && validatedPivotFallback) return fallbackPrice;\n\n // Lastly compare main price and fallback price\n if (\n mainPrice != INVALID_PRICE &&\n fallbackPrice != INVALID_PRICE &&\n boundValidator.validatePriceWithAnchorPrice(asset, mainPrice, fallbackPrice)\n ) {\n return mainPrice;\n }\n\n revert(\"invalid resilient oracle price\");\n }\n\n /**\n * @notice Gets a price for the provided asset\n * @dev This function won't revert when price is 0, because the fallback oracle may still be\n * able to fetch a correct price\n * @param asset asset address\n * @param pivotPrice Pivot oracle price\n * @param pivotEnabled If pivot oracle is not empty and enabled\n * @return price USD price in scaled decimals\n * e.g. asset decimals is 8 then price is returned as 10**18 * 10**(18-8) = 10**28 decimals\n * @return pivotValidated Boolean representing if the validation of main oracle price\n * and pivot oracle price were successful\n * @custom:error Invalid price error is thrown if main oracle fails to fetch price of the asset\n * @custom:error Invalid price error is thrown if main oracle is not enabled or main oracle\n * address is null\n */\n function _getMainOraclePrice(\n address asset,\n uint256 pivotPrice,\n bool pivotEnabled\n ) internal view returns (uint256, bool) {\n (address mainOracle, bool mainOracleEnabled) = getOracle(asset, OracleRole.MAIN);\n if (mainOracleEnabled && mainOracle != address(0)) {\n try OracleInterface(mainOracle).getPrice(asset) returns (uint256 mainOraclePrice) {\n if (!pivotEnabled) {\n return (mainOraclePrice, true);\n }\n if (pivotPrice == INVALID_PRICE) {\n return (mainOraclePrice, false);\n }\n return (\n mainOraclePrice,\n boundValidator.validatePriceWithAnchorPrice(asset, mainOraclePrice, pivotPrice)\n );\n } catch {\n return (INVALID_PRICE, false);\n }\n }\n\n return (INVALID_PRICE, false);\n }\n\n /**\n * @dev This function won't revert when the price is 0 because getPrice checks if price is > 0\n * @param asset asset address\n * @return price USD price in 18 decimals\n * @return pivotValidated Boolean representing if the validation of fallback oracle price\n * and pivot oracle price were successfully\n * @custom:error Invalid price error is thrown if fallback oracle fails to fetch price of the asset\n * @custom:error Invalid price error is thrown if fallback oracle is not enabled or fallback oracle\n * address is null\n */\n function _getFallbackOraclePrice(address asset, uint256 pivotPrice) private view returns (uint256, bool) {\n (address fallbackOracle, bool fallbackEnabled) = getOracle(asset, OracleRole.FALLBACK);\n if (fallbackEnabled && fallbackOracle != address(0)) {\n try OracleInterface(fallbackOracle).getPrice(asset) returns (uint256 fallbackOraclePrice) {\n if (pivotPrice == INVALID_PRICE) {\n return (fallbackOraclePrice, false);\n }\n return (\n fallbackOraclePrice,\n boundValidator.validatePriceWithAnchorPrice(asset, fallbackOraclePrice, pivotPrice)\n );\n } catch {\n return (INVALID_PRICE, false);\n }\n }\n\n return (INVALID_PRICE, false);\n }\n\n /**\n * @dev This function returns the underlying asset of a vToken\n * @param vToken vToken address\n * @return asset underlying asset address\n */\n function _getUnderlyingAsset(address vToken) private view notNullAddress(vToken) returns (address asset) {\n if (vToken == nativeMarket) {\n asset = NATIVE_TOKEN_ADDR;\n } else if (vToken == vai) {\n asset = vai;\n } else {\n asset = VBep20Interface(vToken).underlying();\n }\n }\n}\n" + }, + "@venusprotocol/solidity-utilities/contracts/constants.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\n/// @dev Base unit for computations, usually used in scaling (multiplications, divisions)\nuint256 constant EXP_SCALE = 1e18;\n\n/// @dev A unit (literal one) in EXP_SCALE, usually used in additions/subtractions\nuint256 constant MANTISSA_ONE = EXP_SCALE;\n\n/// @dev The approximate number of seconds per year\nuint256 constant SECONDS_PER_YEAR = 31_536_000;\n" + }, + "@venusprotocol/solidity-utilities/contracts/validators.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\n/// @notice Thrown if the supplied address is a zero address where it is not allowed\nerror ZeroAddressNotAllowed();\n\n/// @notice Thrown if the supplied value is 0 where it is not allowed\nerror ZeroValueNotAllowed();\n\n/// @notice Checks if the provided address is nonzero, reverts otherwise\n/// @param address_ Address to check\n/// @custom:error ZeroAddressNotAllowed is thrown if the provided address is a zero address\nfunction ensureNonzeroAddress(address address_) pure {\n if (address_ == address(0)) {\n revert ZeroAddressNotAllowed();\n }\n}\n\n/// @notice Checks if the provided value is nonzero, reverts otherwise\n/// @param value_ Value to check\n/// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\nfunction ensureNonzeroValue(uint256 value_) pure {\n if (value_ == 0) {\n revert ZeroValueNotAllowed();\n }\n}\n" + }, + "contracts/Interfaces/IConverterNetwork.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport { IAbstractTokenConverter } from \"../TokenConverter/IAbstractTokenConverter.sol\";\n\n/**\n * @title IConverterNetwork\n * @author Venus\n * @notice Interface implemented by `ConverterNetwork`.\n */\ninterface IConverterNetwork {\n /// @notice Adds new converter to the array\n /// @param _tokenConverter Address of the token converter\n function addTokenConverter(IAbstractTokenConverter _tokenConverter) external;\n\n /// @notice Removes converter from the array\n /// @param _tokenConverter Address of the token converter\n function removeTokenConverter(IAbstractTokenConverter _tokenConverter) external;\n\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\n /// @param _tokenAddressIn Address of tokenIn\n /// @param _tokenAddressOut Address of tokenOut\n /// @return converters Array of the conveters on the basis of the tokens pair\n /// @return convertersBalance Array of balances with respect to token out\n function findTokenConverters(address _tokenAddressIn, address _tokenAddressOut)\n external\n returns (address[] memory converters, uint256[] memory convertersBalance);\n\n /// @notice Used to get the array of converters supporting conversions, arranged in descending order based on token balances\n /// @param _tokenAddressIn Address of tokenIn\n /// @param _tokenAddressOut Address of tokenOut\n /// @return converters Array of the conveters on the basis of the tokens pair\n /// @return convertersBalance Array of balances with respect to token out\n function findTokenConvertersForConverters(address _tokenAddressIn, address _tokenAddressOut)\n external\n returns (address[] memory converters, uint256[] memory convertersBalance);\n\n /// @notice This function returns the array containing all the converters addresses\n /// @return Array containing all the converters addresses\n function getAllConverters() external view returns (IAbstractTokenConverter[] memory);\n\n /// @notice This function checks for given address is converter or not\n /// @param _tokenConverter Address of the token converter\n /// @return boolean true if given address is converter otherwise false\n function isTokenConverter(address _tokenConverter) external view returns (bool);\n}\n" + }, + "contracts/TokenConverter/AbstractTokenConverter.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\nimport { ReentrancyGuardUpgradeable } from \"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\";\nimport { SafeERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\nimport { AccessControlledV8 } from \"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol\";\nimport { IERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\";\nimport { ResilientOracle } from \"@venusprotocol/oracle/contracts/ResilientOracle.sol\";\nimport { ensureNonzeroAddress, ensureNonzeroValue } from \"@venusprotocol/solidity-utilities/contracts/validators.sol\";\nimport { MANTISSA_ONE, EXP_SCALE } from \"@venusprotocol/solidity-utilities/contracts/constants.sol\";\n\nimport { IAbstractTokenConverter } from \"./IAbstractTokenConverter.sol\";\nimport { IConverterNetwork } from \"../Interfaces/IConverterNetwork.sol\";\n\n/// @title AbstractTokenConverter\n/// @author Venus\n/// @notice Abstract contract will be extended by SingleTokenConverter and RiskFundConverter\n/*\n * This contract specifies four functions for converting tokens, each applicable under following circumstances:\n *\n * Case I: TokenIn -> deflationary token, TokenOut -> deflationary token\n * In this scenario, functions supporting fees can only be utilized to convert tokens which are:\n * a. convertExactTokensSupportingFeeOnTransferTokens\n * b. convertForExactTokensSupportingFeeOnTransferTokens\n *\n * Case II: TokenIn -> deflationary token, TokenOut -> non-deflationary token\n * In this scenario, functions supporting fee can only be utilized to convert tokens which are:\n * similar to Case I.\n *\n * Case III: TokenIn -> non-deflationary token, TokenOut -> deflationary token\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\n * a. convertExactTokens\n * b. convertForExactTokens\n * c. convertExactTokensSupportingFeeOnTransferTokens\n * d. convertForExactTokensSupportingFeeOnTransferTokens\n *\n * Case IV: TokenIn -> non-deflationary token, TokenOut -> non-deflationary token\n * In this scenario, functions with or without supporting fee can be utilized to convert tokens which are:\n * similar to Case III.\n *\n * ------------------------------------------------------------------------------------------------------------------------------------\n * Example 1:-\n * tokenInAddress - 0xaaaa.....\n * tokenOutAddress - 0xbbbb.....\n * tokenInAmount - 100\n * tokenOutMinAmount - minimum amount desired by the user(let's say 70)\n * Here user can use `convertExactTokens` or `convertExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\n * then `convertExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertExactTokens` is used).\n * Now first tokenInAddress tokens will be transferred from the user to the contract, on the basis of amount\n * received(as tokenInAddress can be deflationary token) tokenAmountOut will be calculated and will be transferred\n * to the user and if amount sent is less than tokenOutMinAmount, tx will revert. If amount sent is satisfied(let's say\n * 80 or even 70) then at last the actual amount received and the amount that was supposed to be received by the contract will\n * be compared, if they differ then the whole tx will revert as user was supposed to use `convertExactTokensSupportingFeeOnTransferTokens`\n * function for tokenIn as deflationary token.\n *\n * Example 2:-\n * tokenInAddress - 0xaaaa.....\n * tokenOutAddress - 0xbbbb.....\n * tokenInMaxAmount - maximum amount user is willing to provide(let's say 100)\n * tokenOutAmount - 70\n * Here user can use `convertForExactTokens` or `convertForExactTokensSupportingFeeOnTransferTokens`, if tokenIn is deflationary\n * then `convertForExactTokensSupportingFeeOnTransferTokens` should be used(let's suppose `convertForExactTokens` is used),\n * which on the basis of tokenOutAmount provided will calculate tokenInAmount based on the tokens prices and will transfer\n * tokens from the user to the contract, now the actual amount received(as tokenInAddress can be deflationary token) will be\n * compared with tokenInMaxAmount if it is greater, tx will revert. If In amount is satisfied(let's say 90 or even 100) then\n * new tokenOutAmount will be calculated, and tokenOutAddress tokens will be transferred to the user, but at last the\n * old tokenOutAmount and new tokenOutAmount will be compared and if they differ whole tx will revert, because user was\n * supposed to use `convertForExactTokensSupportingFeeOnTransferTokens` function for tokenIn as deflationary token.\n * ------------------------------------------------------------------------------------------------------------------------------------\n *\n * This contract also supports private conversion between the converters:\n * Private conversions:\n * Private conversions is designed in order to convert the maximum amount of tokens received from PSR(to any converter) between\n * existing converters to save incentive and lower the dependency of users for conversion. So Private Conversion will be executed\n * by converters on it's own whenever funds are received from PSR. No incentive will be offered during private conversion.\n *\n * It will execute on updateAssetsState() function call in Converter Contracts. After this function call, converter will first\n * check for the amount received. If base asset is received then it will be directly sent to the destination address and no private\n * conversion will happen otherwise converter will interact with ConverterNetwork contract to find other valid converters who are providing the conversion for:\n *\n * tokenAddressIn: As asset received by that converter on updateAssetsState() function call.\n * tokenAddressOut: As base asset of that converter.\n *\n * ConverterNetwork:\n * This contract will contain all the converters, and will provide valid converters which can perform the execution according to tokenAddressIn\n * and tokenAddressOut provided.\n *\n * findTokenConverters():\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for users).\n *\n * findTokenConvertersForConverters():\n * It will return an array of converter addresses along with their corresponding balances, sorted in descending order based on the converter's balances\n * relative to tokenAddressOut. This function filter the converter addresses on the basis of the conversionAccess(for converters).\n */\n\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\nabstract contract AbstractTokenConverter is AccessControlledV8, IAbstractTokenConverter, ReentrancyGuardUpgradeable {\n using SafeERC20Upgradeable for IERC20Upgradeable;\n\n /// @notice Maximum incentive could be\n uint256 public constant MAX_INCENTIVE = 0.5e18;\n\n /// @notice Min amount to convert for private conversions. Defined in USD, with 18 decimals\n uint256 public minAmountToConvert;\n\n /// @notice Venus price oracle contract\n ResilientOracle public priceOracle;\n\n /// @notice conversion configurations for the existing pairs\n /// @dev tokenAddressIn => tokenAddressOut => ConversionConfig\n mapping(address => mapping(address => ConversionConfig)) public conversionConfigurations;\n\n /// @notice Address that all incoming tokens are transferred to\n address public destinationAddress;\n\n /// @notice Boolean for if conversion is paused\n bool public conversionPaused;\n\n /// @notice Address of the converterNetwork contract\n IConverterNetwork public converterNetwork;\n\n /// @dev This empty reserved space is put in place to allow future versions to add new\n /// variables without shifting down storage in the inheritance chain.\n /// See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n uint256[45] private __gap;\n\n /// @notice Emitted when config is updated for tokens pair\n event ConversionConfigUpdated(\n address indexed tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 oldIncentive,\n uint256 newIncentive,\n ConversionAccessibility oldAccess,\n ConversionAccessibility newAccess\n );\n /// @notice Emitted when price oracle address is updated\n event PriceOracleUpdated(ResilientOracle indexed oldPriceOracle, ResilientOracle indexed priceOracle);\n\n /// @notice Emitted when destination address is updated\n event DestinationAddressUpdated(address indexed oldDestinationAddress, address indexed destinationAddress);\n\n /// @notice Emitted when converterNetwork address is updated\n event ConverterNetworkAddressUpdated(address indexed oldConverterNetwork, address indexed converterNetwork);\n\n /// @notice Emitted when exact amount of tokens are converted for tokens\n event ConvertedExactTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when tokens are converted for exact amount of tokens\n event ConvertedForExactTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when exact amount of tokens are converted for tokens, for deflationary tokens\n event ConvertedExactTokensSupportingFeeOnTransferTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when tokens are converted for exact amount of tokens, for deflationary tokens\n event ConvertedForExactTokensSupportingFeeOnTransferTokens(\n address indexed sender,\n address indexed receiver,\n address tokenAddressIn,\n address indexed tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n );\n\n /// @notice Emitted when conversion is paused\n event ConversionPaused(address indexed sender);\n\n /// @notice Emitted when conversion is unpaused\n event ConversionResumed(address indexed sender);\n\n /// @notice Event emitted when tokens are swept\n event SweepToken(address indexed token, address indexed to, uint256 amount);\n\n /// @notice Emitted when minimum amount to convert is updated\n event MinAmountToConvertUpdated(uint256 oldMinAmountToConvert, uint256 newMinAmountToConvert);\n\n /// @notice Thrown when actualAmountOut does not match with amountOutMantissa for convertForExactTokens\n error AmountOutMismatched();\n\n /// @notice Thrown when actualAmountIn does not match with amountInMantissa for convertForExactTokens\n error AmountInMismatched();\n\n /// @notice Thrown when given input amount is zero\n error InsufficientInputAmount();\n\n /// @notice Thrown when given output amount is zero\n error InsufficientOutputAmount();\n\n /// @notice Thrown when conversion is disabled or config does not exist for given pair\n error ConversionConfigNotEnabled();\n\n /// @notice Thrown when conversion is enabled only for private conversions\n error ConversionEnabledOnlyForPrivateConversions();\n\n /// @notice Thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n error InvalidToAddress();\n\n /// @notice Thrown when incentive is higher than the MAX_INCENTIVE\n error IncentiveTooHigh(uint256 incentive, uint256 maxIncentive);\n\n /// @notice Thrown when amountOut is lower than amountOutMin\n error AmountOutLowerThanMinRequired(uint256 amountOutMantissa, uint256 amountOutMinMantissa);\n\n /// @notice Thrown when amountIn is higher than amountInMax\n error AmountInHigherThanMax(uint256 amountInMantissa, uint256 amountInMaxMantissa);\n\n /// @notice Thrown when conversion is paused\n error ConversionTokensPaused();\n\n /// @notice Thrown when conversion is Active\n error ConversionTokensActive();\n\n /// @notice Thrown when tokenInAddress is same as tokeOutAdress OR tokeInAddress is not the base asset of the destination\n error InvalidTokenConfigAddresses();\n\n /// @notice Thrown when contract has less liquidity for tokenAddressOut than amountOutMantissa\n error InsufficientPoolLiquidity();\n\n /// @notice When address of the ConverterNetwork is not set or Zero address\n error InvalidConverterNetwork();\n\n /// @notice Thrown when trying to set non zero incentive for private conversion\n error NonZeroIncentiveForPrivateConversion();\n\n /// @notice Thrown when using convertForExactTokens deflationary tokens\n error DeflationaryTokenNotSupported();\n\n /// @notice Thrown when minimum amount to convert is zero\n error InvalidMinimumAmountToConvert();\n\n /// @notice Thrown when there is a mismatch in the length of input arrays\n error InputLengthMisMatch();\n\n /**\n * @notice Modifier to ensure valid conversion parameters for a token conversion\n * and check if conversion is paused or not\n * @param to The recipient address for the converted tokens\n * @param tokenAddressIn The input token address for the conversion\n * @param tokenAddressOut The output token address for the conversion\n */\n modifier validConversionParameters(\n address to,\n address tokenAddressIn,\n address tokenAddressOut\n ) {\n _checkConversionPaused();\n ensureNonzeroAddress(to);\n if (to == tokenAddressIn || to == tokenAddressOut) {\n revert InvalidToAddress();\n }\n _;\n }\n\n /// @notice Pause conversion of tokens\n /// @custom:event Emits ConversionPaused on success\n /// @custom:error ConversionTokensPaused thrown when conversion is already paused\n /// @custom:access Restricted by ACM\n function pauseConversion() external {\n _checkAccessAllowed(\"pauseConversion()\");\n _checkConversionPaused();\n conversionPaused = true;\n emit ConversionPaused(msg.sender);\n }\n\n /// @notice Resume conversion of tokens.\n /// @custom:event Emits ConversionResumed on success\n /// @custom:error ConversionTokensActive thrown when conversion is already active\n /// @custom:access Restricted by ACM\n function resumeConversion() external {\n _checkAccessAllowed(\"resumeConversion()\");\n if (!conversionPaused) {\n revert ConversionTokensActive();\n }\n\n conversionPaused = false;\n emit ConversionResumed(msg.sender);\n }\n\n /// @notice Sets a new price oracle\n /// @param priceOracle_ Address of the new price oracle to set\n /// @custom:access Only Governance\n function setPriceOracle(ResilientOracle priceOracle_) external onlyOwner {\n _setPriceOracle(priceOracle_);\n }\n\n /// @notice Sets a new destination address\n /// @param destinationAddress_ The new destination address to be set\n /// @custom:access Only Governance\n function setDestination(address destinationAddress_) external onlyOwner {\n _setDestination(destinationAddress_);\n }\n\n /// @notice Sets a converter network contract address\n /// @param converterNetwork_ The converterNetwork address to be set\n /// @custom:access Only Governance\n function setConverterNetwork(IConverterNetwork converterNetwork_) external onlyOwner {\n _setConverterNetwork(converterNetwork_);\n }\n\n /// @notice Min amount to convert setter\n /// @param minAmountToConvert_ Min amount to convert\n /// @custom:access Only Governance\n function setMinAmountToConvert(uint256 minAmountToConvert_) external {\n _checkAccessAllowed(\"setMinAmountToConvert(uint256)\");\n _setMinAmountToConvert(minAmountToConvert_);\n }\n\n /// @notice Batch sets the conversion configurations\n /// @param tokenAddressIn Address of tokenIn\n /// @param tokenAddressesOut Array of addresses of tokenOut\n /// @param conversionConfigs Array of conversionConfig config details to update\n /// @custom:error InputLengthMisMatch is thrown when tokenAddressesOut and conversionConfigs array length mismatches\n function setConversionConfigs(\n address tokenAddressIn,\n address[] calldata tokenAddressesOut,\n ConversionConfig[] calldata conversionConfigs\n ) external {\n uint256 tokenOutArrayLength = tokenAddressesOut.length;\n if (tokenOutArrayLength != conversionConfigs.length) revert InputLengthMisMatch();\n\n for (uint256 i; i < tokenOutArrayLength; ) {\n setConversionConfig(tokenAddressIn, tokenAddressesOut[i], conversionConfigs[i]);\n unchecked {\n ++i;\n }\n }\n }\n\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedExactTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n /// @custom:error AmountInMismatched error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n function convertExactTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\n amountInMantissa,\n amountOutMinMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n if (actualAmountIn != amountInMantissa) {\n revert AmountInMismatched();\n }\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n }\n\n /// @notice Converts tokens for tokenAddressIn for exact amount of tokenAddressOut if there is enough tokens held by the contract,\n /// otherwise the amount is adjusted\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedForExactTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n /// @custom:error AmountOutMismatched error is thrown when actualAmountOut is does not match amountOutMantissa\n function convertForExactTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertForExactTokens(\n amountInMaxMantissa,\n amountOutMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n if (actualAmountOut != amountOutMantissa) {\n revert AmountOutMismatched();\n }\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedForExactTokens(msg.sender, to, tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n }\n\n /// @notice Converts exact amount of tokenAddressIn for tokenAddressOut if there is enough tokens held by the contract\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedExactTokensSupportingFeeOnTransferTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n function convertExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertExactTokens(\n amountInMantissa,\n amountOutMinMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedExactTokensSupportingFeeOnTransferTokens(\n msg.sender,\n to,\n tokenAddressIn,\n tokenAddressOut,\n actualAmountIn,\n actualAmountOut\n );\n }\n\n /// @notice Converts tokens for tokenAddressIn for amount of tokenAddressOut calculated on the basis of amount of\n /// tokenAddressIn received by the contract, if there is enough tokens held by the contract, otherwise the amount is adjusted.\n /// The user will be responsible for bearing any fees associated with token transfers, whether pulling in or pushing out tokens\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount transferred to destination\n /// @return actualAmountOut Actual amount transferred to user\n /// @custom:event Emits ConvertedForExactTokensSupportingFeeOnTransferTokens event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when to address is zero\n /// @custom:error InvalidToAddress error is thrown when address(to) is same as tokenAddressIn or tokenAddressOut\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n function convertForExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n )\n external\n validConversionParameters(to, tokenAddressIn, tokenAddressOut)\n nonReentrant\n returns (uint256 actualAmountIn, uint256 actualAmountOut)\n {\n (actualAmountIn, actualAmountOut) = _convertForExactTokensSupportingFeeOnTransferTokens(\n amountInMaxMantissa,\n amountOutMantissa,\n tokenAddressIn,\n tokenAddressOut,\n to\n );\n\n _postConversionHook(tokenAddressIn, tokenAddressOut, actualAmountIn, actualAmountOut);\n emit ConvertedForExactTokensSupportingFeeOnTransferTokens(\n msg.sender,\n to,\n tokenAddressIn,\n tokenAddressOut,\n actualAmountIn,\n actualAmountOut\n );\n }\n\n /// @notice To sweep ERC20 tokens and transfer them to user(to address)\n /// @param tokenAddress The address of the ERC-20 token to sweep\n /// @param to The address to which tokens will be transferred\n /// @param amount The amount to transfer\n /// @custom:event Emits SweepToken event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero\n /// @custom:access Only Governance\n function sweepToken(\n address tokenAddress,\n address to,\n uint256 amount\n ) external onlyOwner nonReentrant {\n ensureNonzeroAddress(tokenAddress);\n ensureNonzeroAddress(to);\n ensureNonzeroValue(amount);\n\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\n preSweepToken(tokenAddress, amount);\n token.safeTransfer(to, amount);\n\n emit SweepToken(tokenAddress, to, amount);\n }\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn.\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\n /// @notice The amountInMantissa might be adjusted if amountOutMantissa is greater than the balance of the contract for tokenAddressOut\n /// @dev This function retrieves values without altering token prices\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\n function getAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\n if (\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\n ConversionAccessibility.ONLY_FOR_CONVERTERS\n ) {\n revert ConversionEnabledOnlyForPrivateConversions();\n }\n\n amountConvertedMantissa = amountInMantissa;\n uint256 tokenInToOutConversion;\n (amountOutMantissa, tokenInToOutConversion) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\n\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\n\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\n if (maxTokenOutReserve < amountOutMantissa) {\n amountConvertedMantissa = _divRoundingUp(maxTokenOutReserve * EXP_SCALE, tokenInToOutConversion);\n amountOutMantissa = maxTokenOutReserve;\n }\n }\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut.\n /// This function does not account for potential token transfer fees(in case of deflationary tokens)\n /// @dev This function retrieves values without altering token prices\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\n function getAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\n if (\n conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\n ConversionAccessibility.ONLY_FOR_CONVERTERS\n ) {\n revert ConversionEnabledOnlyForPrivateConversions();\n }\n\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\n\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\n if (maxTokenOutReserve < amountOutMantissa) {\n amountOutMantissa = maxTokenOutReserve;\n }\n\n amountConvertedMantissa = amountOutMantissa;\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n }\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) public returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa) {\n priceOracle.updateAssetPrice(tokenAddressIn);\n priceOracle.updateAssetPrice(tokenAddressOut);\n\n (amountOutMantissa, ) = _getAmountOut(amountInMantissa, tokenAddressIn, tokenAddressOut);\n amountConvertedMantissa = amountInMantissa;\n }\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) public returns (uint256 amountConvertedMantissa, uint256 amountInMantissa) {\n priceOracle.updateAssetPrice(tokenAddressIn);\n priceOracle.updateAssetPrice(tokenAddressOut);\n\n (amountInMantissa, ) = _getAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n amountConvertedMantissa = amountOutMantissa;\n }\n\n /// @notice This method updated the states of this contract after getting funds from PSR\n /// after settling the amount(if any) through privateConversion between converters\n /// @dev This function is called by protocolShareReserve\n /// @dev call _updateAssetsState to update the states related to the comptroller and asset transfer to the specific converter then\n /// it calls the _privateConversion which will convert the asset into destination's base asset and transfer it to destination address\n /// @param comptroller Comptroller address (pool)\n /// @param asset Asset address\n function updateAssetsState(address comptroller, address asset) public nonReentrant {\n uint256 balanceDiff = _updateAssetsState(comptroller, asset);\n if (balanceDiff > 0) {\n _privateConversion(comptroller, asset, balanceDiff);\n }\n }\n\n /// @notice Set the configuration for new or existing conversion pair\n /// @param tokenAddressIn Address of tokenIn\n /// @param tokenAddressOut Address of tokenOut\n /// @param conversionConfig ConversionConfig config details to update\n /// @custom:event Emits ConversionConfigUpdated event on success\n /// @custom:error Unauthorized error is thrown when the call is not authorized by AccessControlManager\n /// @custom:error ZeroAddressNotAllowed is thrown when pool registry address is zero\n /// @custom:error NonZeroIncentiveForPrivateConversion is thrown when incentive is non zero for private conversion\n /// @custom:access Controlled by AccessControlManager\n function setConversionConfig(\n address tokenAddressIn,\n address tokenAddressOut,\n ConversionConfig calldata conversionConfig\n ) public {\n _checkAccessAllowed(\"setConversionConfig(address,address,ConversionConfig)\");\n ensureNonzeroAddress(tokenAddressIn);\n ensureNonzeroAddress(tokenAddressOut);\n\n if (conversionConfig.incentive > MAX_INCENTIVE) {\n revert IncentiveTooHigh(conversionConfig.incentive, MAX_INCENTIVE);\n }\n\n if (\n (tokenAddressIn == tokenAddressOut) ||\n (tokenAddressIn != _getDestinationBaseAsset()) ||\n conversionConfigurations[tokenAddressOut][tokenAddressIn].conversionAccess != ConversionAccessibility.NONE\n ) {\n revert InvalidTokenConfigAddresses();\n }\n\n if (\n (conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) &&\n conversionConfig.incentive != 0\n ) {\n revert NonZeroIncentiveForPrivateConversion();\n }\n\n if (\n ((conversionConfig.conversionAccess == ConversionAccessibility.ONLY_FOR_CONVERTERS) ||\n (conversionConfig.conversionAccess == ConversionAccessibility.ALL)) &&\n (address(converterNetwork) == address(0))\n ) {\n revert InvalidConverterNetwork();\n }\n\n ConversionConfig storage configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\n\n emit ConversionConfigUpdated(\n tokenAddressIn,\n tokenAddressOut,\n configuration.incentive,\n conversionConfig.incentive,\n configuration.conversionAccess,\n conversionConfig.conversionAccess\n );\n\n if (conversionConfig.conversionAccess == ConversionAccessibility.NONE) {\n delete conversionConfigurations[tokenAddressIn][tokenAddressOut];\n } else {\n configuration.incentive = conversionConfig.incentive;\n configuration.conversionAccess = conversionConfig.conversionAccess;\n }\n }\n\n /// @notice Get the balance for specific token\n /// @param token Address of the token\n /// @return tokenBalance Balance of the token the contract has\n function balanceOf(address token) public view virtual returns (uint256 tokenBalance);\n\n /// @dev Operations to perform before sweeping tokens\n /// @param token Address of the token\n /// @param amount Amount transferred to address(to)\n function preSweepToken(address token, uint256 amount) internal virtual {}\n\n /// @dev Converts exact amount of tokenAddressIn for tokenAddressOut\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\n /// @return amountOutMantissa Actual amount of tokenAddressOut transferred\n /// @custom:error AmountOutLowerThanMinRequired error is thrown when amount of output tokenAddressOut is less than amountOutMinMantissa\n function _convertExactTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) internal returns (uint256 actualAmountIn, uint256 amountOutMantissa) {\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\n\n (, amountOutMantissa) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\n\n if (amountOutMantissa < amountOutMinMantissa) {\n revert AmountOutLowerThanMinRequired(amountOutMantissa, amountOutMinMantissa);\n }\n\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\n }\n\n /// @dev Converts tokens for tokenAddressIn for exact amount of tokenAddressOut used for non deflationry tokens\n /// it is called by convertForExactTokens function\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\n /// @custom:error DeflationaryTokenNotSupported is thrown if tokenAddressIn is deflationary token\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n function _convertForExactTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\n\n if (actualAmountIn != amountInMantissa) {\n revert DeflationaryTokenNotSupported();\n }\n\n if (actualAmountIn > amountInMaxMantissa) {\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\n }\n\n _doTransferOut(tokenAddressOut, to, amountOutMantissa);\n actualAmountOut = amountOutMantissa;\n }\n\n /// @dev Converts tokens for tokenAddressIn for the amount of tokenAddressOut used for deflationary tokens\n /// it is called by convertForExactTokensSupportingFeeOnTransferTokens function\n /// @notice Advising users to input a smaller amountOutMantissa to avoid potential transaction revert\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @return actualAmountIn Actual amount of tokenAddressIn transferred\n /// @return actualAmountOut Actual amount of tokenAddressOut transferred\n /// @custom:error AmountInHigherThanMax error is thrown when amount of tokenAddressIn is higher than amountInMaxMantissa\n function _convertForExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) internal returns (uint256 actualAmountIn, uint256 actualAmountOut) {\n _checkPrivateConversion(tokenAddressIn, tokenAddressOut);\n (, uint256 amountInMantissa) = getUpdatedAmountIn(amountOutMantissa, tokenAddressIn, tokenAddressOut);\n\n if (amountInMantissa > amountInMaxMantissa) {\n revert AmountInHigherThanMax(amountInMantissa, amountInMaxMantissa);\n }\n\n actualAmountIn = _doTransferIn(tokenAddressIn, amountInMantissa);\n\n (, actualAmountOut) = getUpdatedAmountOut(actualAmountIn, tokenAddressIn, tokenAddressOut);\n\n _doTransferOut(tokenAddressOut, to, actualAmountOut);\n }\n\n /// @dev return actualAmountOut from reserves for tokenAddressOut\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param to Address of the tokenAddressOut receiver\n /// @param amountConvertedMantissa Amount of tokenAddressOut supposed to get transferred\n /// @custom:error InsufficientPoolLiquidity If contract has less liquidity for tokenAddressOut than amountOutMantissa\n function _doTransferOut(\n address tokenAddressOut,\n address to,\n uint256 amountConvertedMantissa\n ) internal {\n uint256 maxTokenOutReserve = balanceOf(tokenAddressOut);\n\n /// If contract has less liquidity for tokenAddressOut than amountOutMantissa\n if (maxTokenOutReserve < amountConvertedMantissa) {\n revert InsufficientPoolLiquidity();\n }\n\n _preTransferHook(tokenAddressOut, amountConvertedMantissa);\n\n IERC20Upgradeable tokenOut = IERC20Upgradeable(tokenAddressOut);\n tokenOut.safeTransfer(to, amountConvertedMantissa);\n }\n\n /// @notice Transfer tokenAddressIn from user to destination\n /// @param tokenAddressIn Address of the token to convert\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @return actualAmountIn Actual amount transferred to destination\n function _doTransferIn(address tokenAddressIn, uint256 amountInMantissa) internal returns (uint256 actualAmountIn) {\n IERC20Upgradeable tokenIn = IERC20Upgradeable(tokenAddressIn);\n uint256 balanceBeforeDestination = tokenIn.balanceOf(destinationAddress);\n tokenIn.safeTransferFrom(msg.sender, destinationAddress, amountInMantissa);\n uint256 balanceAfterDestination = tokenIn.balanceOf(destinationAddress);\n actualAmountIn = balanceAfterDestination - balanceBeforeDestination;\n }\n\n /// @dev Sets a new price oracle\n /// @param priceOracle_ Address of the new price oracle to set\n /// @custom:event Emits PriceOracleUpdated event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when price oracle address is zero\n function _setPriceOracle(ResilientOracle priceOracle_) internal {\n ensureNonzeroAddress(address(priceOracle_));\n emit PriceOracleUpdated(priceOracle, priceOracle_);\n priceOracle = priceOracle_;\n }\n\n /// @dev Sets a new destination address\n /// @param destinationAddress_ The new destination address to be set\n /// @custom:event Emits DestinationAddressUpdated event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when destination address is zero\n function _setDestination(address destinationAddress_) internal {\n ensureNonzeroAddress(destinationAddress_);\n emit DestinationAddressUpdated(destinationAddress, destinationAddress_);\n destinationAddress = destinationAddress_;\n }\n\n /// @notice Sets a converter network contract address\n /// @param converterNetwork_ The converterNetwork address to be set\n /// @custom:event Emits ConverterNetworkAddressUpdated event on success\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\n function _setConverterNetwork(IConverterNetwork converterNetwork_) internal {\n ensureNonzeroAddress(address(converterNetwork_));\n emit ConverterNetworkAddressUpdated(address(converterNetwork), address(converterNetwork_));\n converterNetwork = converterNetwork_;\n }\n\n /// @notice Min amount to convert setter\n /// @param minAmountToConvert_ Min amount to convert\n /// @custom:event MinAmountToConvertUpdated is emitted in success\n /// @custom:error ZeroValueNotAllowed is thrown if the provided value is 0\n function _setMinAmountToConvert(uint256 minAmountToConvert_) internal {\n ensureNonzeroValue(minAmountToConvert_);\n emit MinAmountToConvertUpdated(minAmountToConvert, minAmountToConvert_);\n minAmountToConvert = minAmountToConvert_;\n }\n\n /// @dev Hook to perform after converting tokens\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @param amountIn Amount of tokenIn converted\n /// @param amountOut Amount of tokenOut converted\n function _postConversionHook(\n address tokenAddressIn,\n address tokenAddressOut,\n uint256 amountIn,\n uint256 amountOut\n ) internal virtual {}\n\n /// @param accessControlManager_ Access control manager contract address\n /// @param priceOracle_ Resilient oracle address\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\n /// @param minAmountToConvert_ minimum amount to convert\n function __AbstractTokenConverter_init(\n address accessControlManager_,\n ResilientOracle priceOracle_,\n address destinationAddress_,\n uint256 minAmountToConvert_\n ) internal onlyInitializing {\n __AccessControlled_init(accessControlManager_);\n __ReentrancyGuard_init();\n __AbstractTokenConverter_init_unchained(priceOracle_, destinationAddress_, minAmountToConvert_);\n }\n\n /// @param priceOracle_ Resilient oracle address\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\n /// @param minAmountToConvert_ minimum amount to convert\n function __AbstractTokenConverter_init_unchained(\n ResilientOracle priceOracle_,\n address destinationAddress_,\n uint256 minAmountToConvert_\n ) internal onlyInitializing {\n _setPriceOracle(priceOracle_);\n _setDestination(destinationAddress_);\n _setMinAmountToConvert(minAmountToConvert_);\n conversionPaused = false;\n }\n\n /// @dev _updateAssetsState hook to update the states of reserves transferred for the specific comptroller\n /// @param comptroller Comptroller address (pool)\n /// @param asset Asset address\n /// @return Amount of asset, for _privateConversion\n function _updateAssetsState(address comptroller, address asset) internal virtual returns (uint256) {}\n\n /// @dev This method is used to convert asset into base asset by converting them with other converters which supports the pair and transfer the funds to\n /// destination contract as destination's base asset\n /// @param comptroller Comptroller address (pool)\n /// @param tokenAddressOut Address of the token transferred to converter, and through _privateConversion it will be converted into base asset\n /// @param amountToConvert Amount of the tokenAddressOut transferred to converter\n function _privateConversion(\n address comptroller,\n address tokenAddressOut,\n uint256 amountToConvert\n ) internal {\n address tokenAddressIn = _getDestinationBaseAsset();\n address _destinationAddress = destinationAddress;\n uint256 convertedTokenInBalance;\n if (address(converterNetwork) != address(0)) {\n (address[] memory converterAddresses, uint256[] memory converterBalances) = converterNetwork\n .findTokenConvertersForConverters(tokenAddressOut, tokenAddressIn);\n uint256 convertersLength = converterAddresses.length;\n for (uint256 i; i < convertersLength; ) {\n if (converterBalances[i] == 0) break;\n (, uint256 amountIn) = IAbstractTokenConverter(converterAddresses[i]).getUpdatedAmountIn(\n converterBalances[i],\n tokenAddressOut,\n tokenAddressIn\n );\n if (amountIn > amountToConvert) {\n amountIn = amountToConvert;\n }\n\n if (!_validateMinAmountToConvert(amountIn, tokenAddressOut)) {\n break;\n }\n\n uint256 balanceBefore = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\n\n IERC20Upgradeable(tokenAddressOut).forceApprove(converterAddresses[i], amountIn);\n IAbstractTokenConverter(converterAddresses[i]).convertExactTokens(\n amountIn,\n 0,\n tokenAddressOut,\n tokenAddressIn,\n _destinationAddress\n );\n\n uint256 balanceAfter = IERC20Upgradeable(tokenAddressIn).balanceOf(_destinationAddress);\n amountToConvert -= amountIn;\n convertedTokenInBalance += (balanceAfter - balanceBefore);\n\n if (amountToConvert == 0) break;\n unchecked {\n ++i;\n }\n }\n }\n\n _postPrivateConversionHook(\n comptroller,\n tokenAddressIn,\n convertedTokenInBalance,\n tokenAddressOut,\n amountToConvert\n );\n }\n\n /// @dev This hook is used to update states for the converter after the privateConversion\n /// @param comptroller Comptroller address (pool)\n /// @param tokenAddressIn Address of the destination's base asset\n /// @param convertedTokenInBalance Amount of the base asset received after the conversion\n /// @param tokenAddressOut Address of the asset transferred to other converter in exchange of base asset\n /// @param convertedTokenOutBalance Amount of tokenAddressOut transferred from this converter\n function _postPrivateConversionHook(\n address comptroller,\n address tokenAddressIn,\n uint256 convertedTokenInBalance,\n address tokenAddressOut,\n uint256 convertedTokenOutBalance\n ) internal virtual {}\n\n /// @notice This hook is used to update the state for asset reserves before transferring tokenOut to user\n /// @param tokenOutAddress Address of the asset to be transferred to the user\n /// @param amountOut Amount of tokenAddressOut transferred from this converter\n function _preTransferHook(address tokenOutAddress, uint256 amountOut) internal virtual {}\n\n /// @dev Checks if amount to convert is greater than minimum amount to convert or not\n /// @param amountIn The amount to convert\n /// @param tokenAddress Address of the token\n /// @return isValid true if amount to convert is greater than minimum amount to convert\n function _validateMinAmountToConvert(uint256 amountIn, address tokenAddress) internal returns (bool isValid) {\n priceOracle.updateAssetPrice(tokenAddress);\n uint256 amountInInUsd = (priceOracle.getPrice(tokenAddress) * amountIn) / EXP_SCALE;\n\n if (amountInInUsd >= minAmountToConvert) {\n isValid = true;\n }\n }\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @dev This function retrieves values without altering token prices.\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function _getAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) internal view returns (uint256 amountOutMantissa, uint256 tokenInToOutConversion) {\n if (amountInMantissa == 0) {\n revert InsufficientInputAmount();\n }\n\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\n\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\n revert ConversionConfigNotEnabled();\n }\n\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\n\n uint256 incentive = configuration.incentive;\n if (address(converterNetwork) != address(0) && (converterNetwork.isTokenConverter(msg.sender))) {\n incentive = 0;\n }\n\n /// conversion rate after considering incentive(conversionWithIncentive)\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\n\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\n /// amount of tokenAddressOut after including incentive as amountOutMantissa will be greater than actual as it gets\n /// multiplied by conversionWithIncentive which will be >= 1\n amountOutMantissa = (amountInMantissa * tokenInToOutConversion) / (EXP_SCALE);\n }\n\n /// @dev To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @dev This function retrieves values without altering token prices.\n /// @dev For user conversions, the function returns an amountInMantissa that is rounded up, ensuring that the equivalent amountInMantissa\n /// is obtained from users for corresponding amountOutMantissa, preventing any losses to the protocol. However, no rounding up is required for private conversions\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @return tokenInToOutConversion Ratio of tokenIn price and incentive for conversion with tokenOut price\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function _getAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) internal view returns (uint256 amountInMantissa, uint256 tokenInToOutConversion) {\n if (amountOutMantissa == 0) {\n revert InsufficientOutputAmount();\n }\n\n ConversionConfig memory configuration = conversionConfigurations[tokenAddressIn][tokenAddressOut];\n\n if (configuration.conversionAccess == ConversionAccessibility.NONE) {\n revert ConversionConfigNotEnabled();\n }\n\n uint256 tokenInUnderlyingPrice = priceOracle.getPrice(tokenAddressIn);\n uint256 tokenOutUnderlyingPrice = priceOracle.getPrice(tokenAddressOut);\n\n uint256 incentive = configuration.incentive;\n\n bool isPrivateConversion = address(converterNetwork) != address(0) &&\n converterNetwork.isTokenConverter(msg.sender);\n if (isPrivateConversion) {\n incentive = 0;\n }\n\n /// conversion rate after considering incentive(conversionWithIncentive)\n uint256 conversionWithIncentive = MANTISSA_ONE + incentive;\n\n /// amount of tokenAddressIn after considering incentive(i.e. amountInMantissa will be less than actual amountInMantissa if incentive > 0)\n if (isPrivateConversion) {\n amountInMantissa =\n (amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE) /\n (tokenInUnderlyingPrice * conversionWithIncentive);\n } else {\n amountInMantissa = _divRoundingUp(\n amountOutMantissa * tokenOutUnderlyingPrice * EXP_SCALE,\n tokenInUnderlyingPrice * conversionWithIncentive\n );\n }\n\n tokenInToOutConversion = (tokenInUnderlyingPrice * conversionWithIncentive) / tokenOutUnderlyingPrice;\n }\n\n /// @dev Check if msg.sender is allowed to convert as per onlyForPrivateConversions flag\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @custom:error ConversionEnabledOnlyForPrivateConversions is thrown when conversion is only enabled for private conversion\n function _checkPrivateConversion(address tokenAddressIn, address tokenAddressOut) internal view {\n bool isConverter = (address(converterNetwork) != address(0)) && converterNetwork.isTokenConverter(msg.sender);\n if (\n (!(isConverter) &&\n (conversionConfigurations[tokenAddressIn][tokenAddressOut].conversionAccess ==\n ConversionAccessibility.ONLY_FOR_CONVERTERS))\n ) {\n revert ConversionEnabledOnlyForPrivateConversions();\n }\n }\n\n /// @dev To check, is conversion paused\n /// @custom:error ConversionTokensPaused is thrown when token conversion is paused\n function _checkConversionPaused() internal view {\n if (conversionPaused) {\n revert ConversionTokensPaused();\n }\n }\n\n /// @dev Get base asset address of the destination contract\n /// @return Address of the base asset\n function _getDestinationBaseAsset() internal view virtual returns (address) {}\n\n /// @dev Performs division where the result is rounded up\n /// @param numerator The numerator of the division operation\n /// @param denominator The denominator of the division operation. Must be non-zero\n /// @return The result of the division, rounded up\n function _divRoundingUp(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\n return (numerator + denominator - 1) / denominator;\n }\n}\n" + }, + "contracts/TokenConverter/IAbstractTokenConverter.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.8.25;\n\nimport { ResilientOracle } from \"@venusprotocol/oracle/contracts/ResilientOracle.sol\";\nimport { IConverterNetwork } from \"../Interfaces/IConverterNetwork.sol\";\n\n/// @notice Interface for AbstractTokenConverter\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\ninterface IAbstractTokenConverter {\n /// @notice This enum define the all possible ways of conversion can happen\n enum ConversionAccessibility {\n NONE, // Conversion is disable for the pair\n ALL, // Conversion is enable for private conversion and users\n ONLY_FOR_CONVERTERS, // Conversion is enable only for private conversion\n ONLY_FOR_USERS // Conversion is enable only for users\n }\n\n /// @notice This struct represents the configuration for a token conversion.\n struct ConversionConfig {\n /// incentive on conversion of tokens in mantissa i.e 10% incentive would be 0.1 * 1e18\n uint256 incentive;\n /// enable or disable conversion for users or converters or both or none\n ConversionAccessibility conversionAccess;\n }\n\n /// @notice Pause conversion of tokens\n function pauseConversion() external;\n\n /// @notice Resume conversion of tokens.\n function resumeConversion() external;\n\n /// @notice Sets a new price oracle\n /// @param priceOracle_ Address of the new price oracle to set\n function setPriceOracle(ResilientOracle priceOracle_) external;\n\n /// @notice Set the configuration for new or existing convert pair\n /// @param tokenAddressIn Address of tokenIn\n /// @param tokenAddressOut Address of tokenOut\n /// @param conversionConfig ConversionConfig config details to update\n function setConversionConfig(\n address tokenAddressIn,\n address tokenAddressOut,\n ConversionConfig calldata conversionConfig\n ) external;\n\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertExactTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\n /// @dev Method does not support deflationary tokens transfer\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertForExactTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Convert exact amount of tokenAddressIn for tokenAddressOut\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param amountOutMinMantissa Min amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMantissa,\n uint256 amountOutMinMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Convert tokens for tokenAddressIn for exact amount of tokenAddressOut\n /// @param amountInMaxMantissa Max amount of tokenAddressIn\n /// @param amountOutMantissa Amount of tokenAddressOut required as output\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after convert\n /// @param to Address of the tokenAddressOut receiver\n function convertForExactTokensSupportingFeeOnTransferTokens(\n uint256 amountInMaxMantissa,\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut,\n address to\n ) external returns (uint256 actualAmountIn, uint256 actualAmountOut);\n\n /// @notice Get the configuration for the pair of the tokens\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return incentives Percentage of incentives to be distributed for the pair of tokens\n /// @return conversionAccess Accessibility for the pair of tokens\n function conversionConfigurations(address tokenAddressIn, address tokenAddressOut)\n external\n returns (uint256 incentives, ConversionAccessibility conversionAccess);\n\n /// @notice Get the address of the converterNetwork\n function converterNetwork() external returns (IConverterNetwork converterNetwork);\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getUpdatedAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\n\n /// @notice To get the amount of tokenAddressIn tokens sender would send on receiving amountOutMantissa tokens of tokenAddressOut\n /// @dev This function retrieves values without altering token prices.\n /// @param amountOutMantissa Amount of tokenAddressOut user wants to receive\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressOut should be transferred after conversion\n /// @return amountInMantissa Amount of the tokenAddressIn sender would send to contract before conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getAmountIn(\n uint256 amountOutMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountInMantissa);\n\n /// @notice To get the amount of tokenAddressOut tokens sender could receive on providing amountInMantissa tokens of tokenAddressIn\n /// @dev This function retrieves values without altering token prices.\n /// @param amountInMantissa Amount of tokenAddressIn\n /// @param tokenAddressIn Address of the token to convert\n /// @param tokenAddressOut Address of the token to get after conversion\n /// @return amountConvertedMantissa Amount of tokenAddressIn should be transferred after conversion\n /// @return amountOutMantissa Amount of the tokenAddressOut sender should receive after conversion\n /// @custom:error InsufficientInputAmount error is thrown when given input amount is zero\n /// @custom:error ConversionConfigNotEnabled is thrown when conversion is disabled or config does not exist for given pair\n function getAmountOut(\n uint256 amountInMantissa,\n address tokenAddressIn,\n address tokenAddressOut\n ) external view returns (uint256 amountConvertedMantissa, uint256 amountOutMantissa);\n\n /// @notice Get the balance for specific token\n /// @param token Address of the token\n /// @return tokenBalance Balance of the token the contract has\n function balanceOf(address token) external view returns (uint256 tokenBalance);\n}\n" + }, + "contracts/TokenConverter/SingleTokenConverter.sol": { + "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.8.25;\n\nimport { SafeERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\nimport { IERC20Upgradeable } from \"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\";\nimport { ResilientOracle } from \"@venusprotocol/oracle/contracts/ResilientOracle.sol\";\nimport { ensureNonzeroAddress } from \"@venusprotocol/solidity-utilities/contracts/validators.sol\";\n\nimport { AbstractTokenConverter } from \"./AbstractTokenConverter.sol\";\n\n/// @title SingleTokenConverter\n/// @author Venus\n/// @notice SingleTokenConverter used for token conversions and sends received tokens\n/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion\ncontract SingleTokenConverter is AbstractTokenConverter {\n using SafeERC20Upgradeable for IERC20Upgradeable;\n\n /// @notice Address of the base asset token\n address public baseAsset;\n\n /// @notice The mapping contains the assets which are sent to destination directly\n /// @dev Asset -> bool(should transfer directly on true)\n mapping(address => bool) public assetsDirectTransfer;\n\n /// @notice Emitted when base asset is updated\n event BaseAssetUpdated(address indexed oldBaseAsset, address indexed newBaseAsset);\n\n /// @notice Emmitted after the funds transferred to the destination address\n event AssetTransferredToDestination(\n address indexed receiver,\n address indexed comptroller,\n address indexed asset,\n uint256 amount\n );\n\n /// @notice Emitted after the assetsDirectTransfer mapping is updated\n event AssetsDirectTransferUpdated(address indexed receiver, address indexed asset, bool value);\n\n /// @notice Thrown when the base asset is the same as the new base asset\n error SameBaseAssetNotAllowed();\n\n /// @notice Thrown if someone tries to add `baseAssets` to the `assetsDirectTransfer` collection\n error DirectTransferBaseAssetNotAllowed();\n\n /// @notice Thrown when the `assetsDirectTransfer[asset]` is already `value`\n /// @param asset The asset address whose `assetDirectTransfer` value went to be set\n /// @param value The value to be set\n error SameAssetDirectTransferNotAllowed(address asset, bool value);\n\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor() {\n // Note that the contract is upgradeable. Use initialize() or reinitializers\n // to set the state variables.\n _disableInitializers();\n }\n\n /// @param accessControlManager_ Access control manager contract address\n /// @param priceOracle_ Resilient oracle address\n /// @param destinationAddress_ Address at all incoming tokens will transferred to\n /// @param baseAsset_ Address of the base asset\n /// @param minAmountToConvert_ Minimum amount to convert\n function initialize(\n address accessControlManager_,\n ResilientOracle priceOracle_,\n address destinationAddress_,\n address baseAsset_,\n uint256 minAmountToConvert_\n ) public initializer {\n _setBaseAsset(baseAsset_);\n\n // Initialize AbstractTokenConverter\n __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);\n }\n\n /// @notice Sets the base asset for the contract\n /// @param baseAsset_ The new address of the base asset\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\n /// @custom:event BaseAssetUpdated is emitted on success\n /// @custom:access Only Governance\n function setBaseAsset(address baseAsset_) external onlyOwner {\n _setBaseAsset(baseAsset_);\n }\n\n /// @notice Update the assetsDirectTransfer mapping\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\n /// @custom:event AssetsDirectTransferUpdated emits on success\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\n /// @custom:access Restricted by ACM\n function setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) external virtual {\n _checkAccessAllowed(\"setAssetsDirectTransfer(address[],bool[])\");\n _setAssetsDirectTransfer(assets, values);\n }\n\n /// @notice Get the balance for specific token\n /// @param tokenAddress Address of the token\n /// @return tokenBalance Balance of the token the contract has\n function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {\n IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);\n tokenBalance = token.balanceOf(address(this));\n }\n\n /// @dev It returns the balance of the `asset` in this contract. If `asset` is the `baseAsset`\n /// or `assetsDirectTransfer[asset]` is true, then the balance of `asset` in this contract will\n /// be transferred to the `destinationAddress` and 0 will be returned\n /// @param comptroller Comptroller address (pool)\n /// @param asset Asset address.\n /// @return balanceLeft Amount of asset, for _privateConversion\n function _updateAssetsState(address comptroller, address asset) internal override returns (uint256 balanceLeft) {\n IERC20Upgradeable token = IERC20Upgradeable(asset);\n uint256 balance = token.balanceOf(address(this));\n balanceLeft = balance;\n\n if (asset == baseAsset || assetsDirectTransfer[asset]) {\n balanceLeft = 0;\n token.safeTransfer(destinationAddress, balance);\n emit AssetTransferredToDestination(destinationAddress, comptroller, asset, balance);\n }\n }\n\n /// @notice Hook called after a private conversion is completed\n /// @dev Emits an AssetTransferredToDestination event if Private Conversion happens\n /// @param comptroller The address of the comptroller (pool) associated with the conversion\n /// @param tokenAddressIn The address of the input token that was converted\n /// @param convertedTokenInBalance The amount of input token that was converted\n /// @custom:event AssetTransferredToDestination Emitted when convertedTokenInBalance > 0, indicating\n /// the converted assets were transferred to the destination address\n function _postPrivateConversionHook(\n address comptroller,\n address tokenAddressIn,\n uint256 convertedTokenInBalance,\n address,\n uint256\n ) internal override {\n if (convertedTokenInBalance > 0) {\n emit AssetTransferredToDestination(\n destinationAddress,\n comptroller,\n tokenAddressIn,\n convertedTokenInBalance\n );\n }\n }\n\n /// @dev Update the assetsDirectTransfer mapping for destinationAddress\n /// @param assets Addresses of the assets need to be added or removed for direct transfer\n /// @param values Boolean value to indicate whether direct transfer is allowed for each asset.\n /// @custom:event AssetsDirectTransferUpdated emits on success\n /// @custom:error InputLengthMisMatch thrown when assets and values array lengths don't match\n /// @custom:error DirectTransferBaseAssetNotAllowed thrown when an asset in `assets` is the `baseAsset`\n /// @custom:error SameAssetDirectTransferNotAllowed thrown when the value to set for an asset doesn't differs\n /// from its current value\n function _setAssetsDirectTransfer(address[] calldata assets, bool[] calldata values) internal {\n uint256 assetsLength = assets.length;\n\n if (assetsLength != values.length) {\n revert InputLengthMisMatch();\n }\n\n for (uint256 i; i < assetsLength; ++i) {\n if (assets[i] == baseAsset) {\n revert DirectTransferBaseAssetNotAllowed();\n }\n\n if (assetsDirectTransfer[assets[i]] == values[i]) {\n revert SameAssetDirectTransferNotAllowed(assets[i], values[i]);\n }\n\n assetsDirectTransfer[assets[i]] = values[i];\n emit AssetsDirectTransferUpdated(destinationAddress, assets[i], values[i]);\n }\n }\n\n /// @dev Sets the base asset for the contract\n /// @param baseAsset_ The new address of the base asset\n /// @custom:error ZeroAddressNotAllowed is thrown when address is zero\n /// @custom:error SameBaseAssetNotAllowed is thrown when `baseAsset_` is equal to the current base asset\n /// @custom:event BaseAssetUpdated is emitted on success\n function _setBaseAsset(address baseAsset_) internal {\n ensureNonzeroAddress(baseAsset_);\n\n if (baseAsset == baseAsset_) {\n revert SameBaseAssetNotAllowed();\n }\n\n emit BaseAssetUpdated(baseAsset, baseAsset_);\n baseAsset = baseAsset_;\n }\n\n /// @dev Get base asset address\n /// @return destinationBaseAsset Address of the base asset(baseAsset)\n function _getDestinationBaseAsset() internal view override returns (address destinationBaseAsset) {\n destinationBaseAsset = baseAsset;\n }\n}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 10000 + }, + "evmVersion": "paris", + "outputSelection": { + "*": { + "*": [ + "storageLayout", + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "evm.gasEstimates" + ], + "": ["ast"] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} From 2ffeccd3e299f9e7f33d66d15ac8d9d7c93e909b Mon Sep 17 00:00:00 2001 From: Filip Malachowicz Date: Wed, 20 Aug 2025 10:32:39 +0200 Subject: [PATCH 11/15] feat: add audit document --- ...verterWhitelistFeature_certik_20250811.pdf | Bin 0 -> 3491469 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 audits/118_tokenConverterWhitelistFeature_certik_20250811.pdf diff --git a/audits/118_tokenConverterWhitelistFeature_certik_20250811.pdf b/audits/118_tokenConverterWhitelistFeature_certik_20250811.pdf new file mode 100644 index 0000000000000000000000000000000000000000..7bd8967780420b52623330151ffda4c20329b6b1 GIT binary patch literal 3491469 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 l=PmDT6-4zQ`6`3a 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 z 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 z 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 =z*;Ea|Vt2w0AQ;6bPIVkQ!k|iBBBg6)5m_z6 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%0A?E0~s1p-F=+A6HAI%VvqF`Dmg0e06xl zW3IQLlrLmLU@BxrJ1I1qLaTF)pVx&g47_L5%A)f*tFal>Fa&Ba#i*Q|)@Nb@CI((I z>s4l5vD2UmoAd#r*2<_jy^7Ih1@lSp)B&gz0j4NFDx>DhAxg=RR4!UoERQUobCrZR zWiYE;?OrZ6Mc^r_;FCwb_&{M=UUUGybnuXwSA_>j`D7SMW=T=diIAh@^gV@ABO92? z0iz`OUbcd7KR+r5q540D@jV5b$^ohNv8r;PS84$9r6bv((-AT<_)-=Om4EPW=KOLF zS|tt1+bV-i73Kc|Zz^-#$d@IOaFF=K;5}uwm?liwtWGa9I0CW4rlb^H6h!R?ni^@; zB-NBolC-FRss{eh7xZJa9IJ;i!0B=F7O0#IRL4gJ8Vsf#8S%z0rukTWA%8Fuw7VQo z`<0ca{GkAvt{Aka5g?R)xukJ?U9Bsj#^#c* z6k#jDUT`|JpAwaEMnV#^!p1-ifU-fCJqRnc+d)l42?Gs_1PcjZf@%;}6H?`(6+HBP z(8m!sc!o51=+;Gg$s#H#B1>U0=`lr$0vyc3V%Ve-boycqD%f@+CqXxL7AiJ9Mi#nV zMvKM3^SspxQ@NT!3v?QPj3U7zVxFTaDkv%-R!)*#IW>lo;3nz$Lm36%Aqq(;bNA%u z#c@c4tukCGSreDh${}M4b%ObX1eI5S?&U1c*3?%G4E1%S)BOWOv$M0S%S*G97UIB4PgP-{@Um=KxfT3EC;>W!FBlLshOGfs#l8oFB zWsI|O9ki&X@43SnWgms4p34TWWD|99#})om5_RebeT>*tvARgd!gqle3v4hd`-t;7 zjNemhsb?uX^-LzA?n z)zh)5++@9jjHEJ3y(}c^Dbah1)liYdS0XW{Q080=GXQVlpfL}G1M#wWva&phe&*%L z@>FT6tTa^`iN%7^a3~foO(mdZtE#E&=;|049vGV(pPHGTnVTJ-oNVdnXl!li9qgT+ zn`mus2}dIim&+m`9F6=^>T8iv$w?LXQ?V)heK?I_z#P)q)xNwkzqz%sy0W;sy1c%z zytF(wJv%-+K3LyS>kIf@ZimHc#(M;6k|mTej8$d5zlcF8^buLW)B$QfRhF-m3`r@m zDd_>mt!i;@gvktXdvbGJTqE?fKP5i6B%O)D0B(&IN^YIk@2ReYW=mE{~6o*4ET@_jHep4fphRCsSn}w+ostD6mn5tVb(&;%W{hs}2TFezL6AKvD}e z#I*xf2Ut7ci)-y{>FMvDUz$02YIEn}*`1v;w{BmD&pLkM==|dB;K)F2Lp^+JPPYq= zBswrNI%37l(pwBrt0&8o4Ndj!>Gtm4uFmd`?%s4$YeQvqDqb4(`rQ_b*-FRd;d-P|~~b#!@sX<}vq{=B-r2F@<%Lt$;A8DX$=Iy_ET z1d~bzux#yu1`vIy>s+E$H|}ZVd6# zy&jW*k?ydty8T`_Z!7Amn>t#$2D%5vhlZ!d1}8^*hWcC69n}qW(L|ikl?7_s$Po;L znmbV#gbMm#{ety3k_eYqr^+i+sj6gIMOiEvC&uO;tHZ`wOa>yfAj~2jw#w#m!1`XA zEQ395Y;9`kXl+ZkwRW`DH`SGumxUrB_+Bh_R2{Os=z}dYpkxY)WaLYQV2tQgCfZ*k zbVFp4h!;`6%CfRVV^e)cx~;FTdunRz#d|mIzkKKJ?VEdh*DhQAnAn5%-=l-1^PdIJ7P zB3@Nj+nVki7#*3Iot>PU9i5u&9_X)YZi<$bd4d6p&4yOhCKA{tLQfQlq6t}?>{FD% zrX)N{IVdp2o1~tOelLVs4P9h;MH!r96XPR0JEtDpzw_Rs*WP{j`l~PByLId8sqJGE z6T{6d4ds=|K*%rHtt4wt6aexfIEEDw17!~nRf;(r3$=ANFDy=7xOn!}2X`O8|JH{e zyz}0BZ@>7`?K5Y$Cnm?5n;TQ9q{ri?csrZ%GZ(=nf=4k~223ujxRsPTj_;)ihIjD$I_GuzBgpEDc}w|2A~+uXQv z^&(7Pn=#|^e10E1iFt(r%zK`?y2{Ck!JYFb-hcGk=YM+t zkB{HFcXw}NW4Qr+Hi9J705MwwkvEE5DS|grqLheAi2-~X1=W^DV5=p&!V>yZC8_Gf zpK5{^WjIkq6g83rcLYJ&k4;GcR4y>3ItX;i!kv`Q$Xu!H-^pQQ$=H+vo>D8uJ~OLg zrHBt!PmU_Y1&qeyi4$+;DCsp4drB*1*DCV(a=21NY|bjIr8v=7%1A>K;JOg(7Jty= z@jC4e8%>3<+bJYvL(#X#>Gioop+GbmipL^liAY5%mTqfUU7Wgg{lX_7y!FF3PyY7Z z7k~f$i?6@@s`Fw%`+a8!Ea*F)5)Zdo0*iAZ4%fqJGWaM{&>Fg zr)x|9yt44&Li%ETY}99Mb(`wEmU4%w%to*&;(w07l)%Q&`J64avPmmjY3G`pe80;y zV>j-`-H*pxzCSzl_p8f)IW@Lh8yfSP8mvsI1wS#!Q(#ID8xY`iexojE(nZWnT)==o zc*eXSiii}N(nm&;J$p=I0Gz&Hm8k1PZ|>9 zhV&Bz1O|9hTr=Gz68i9YyqJw3Bk#5i-&tFNh-^={N)HQFiAG`oht$FW`gn ziBPlP8Gkqt@dkY+6!+NzH2ufrfB{uH`~qu2X}`rL7%gUR!0U$g!ER-#G{8uAL8U=Y zV^}oRG+~g;_Bs*>rAButVhb-1l$)VTIhMij{;-3B!wS_hHOs=ifTGA|b^2UZ2Ye{j z_GYVz5WV!o{nAW(aq%&YZU^d9uMII{_+b(Y5fzG8S!4H{^}w?J^@y!-;1RY#~q zk{Q$yS%@c5p+vVRg179mnG!*p1F$KDj_=5k=d+(t@}@*=3bqH1Gpt!nO?5*f11&A> z(7^Qf4NQ)Y%}$Pw3=EDBjSlq=Mne&TrlJb90RQU9k-Q^EU@s7)%Fiz>C@3yO@Q~F( zYh0`1l+y)4pH#{B%(zf07ZCtRYiACdTwrdV`Js?0471%zL}HIscoIy zg!Xo9V!WxP+2i+MZYgFun9xW{rz$3~cL*#KeyMCNo*B83)>)2Es3|56a!!wZW_IlC zxf7?hkB^NGH8(eumc<-SJBr|V1567gBB+I$h^K!<4m_1{g3SO^sw`lNLR+H4ImuZN zOJ!|F#HSU_rqq-)g>E6l_(f~b(ti?JA1)b$q`-=SbY`Q~YJ%#OXh}TH?ak}Qmd>3& zapT6N-Am_RdHMEx@4kNb-i^V5-T<^lFrhhY#P*p*c9j9eLk0#1!)Oc!5?07)Sc8UR zwH&MCdB$Qj+8tJJz*Ck=G&DE#4-G7>E}q>vvwP*@%{w=4-@AEr@AAgc)rF;5XzI(# z6K;~SM~!iy-!yWtg}lRI_job7&L8l{;<38Mx`C1Y@#(SAiIH?qIuef%Rs(j~)b7~~dkfPW$5&6EKe>J81Z+d!P+xgfxi92LdJ?&L0c(c_Uy@>ozq*JN7vVvUwQe~otxL;(Zu+~==fN7Z_mW|`0Cm!T)CSk zkIya6)iu^f6G&}xdpyvhM-#DFX(AGh!1smHGzqGlJZ^s&zNutgV^bR5 zZF*{PZDo05b#ivPwX+>w5}Zg*rYIjLio0Z56a_c34BN8|wQ{g2qY|DnQrZ>lHHPka z9D%SeQ5Ng!YTwvcyngM%of}s_di?NDA3b{X_Jh4^m!>Ah+uE9wsZy`sjbH_7LMePf ztSsRHVpGIIoQ2cL<8vm;qOEO>i%T;%Z(n`<{u`fu`oU*^{_x@34{lt)ym|a+Pft3P zO1j)Gq&OlWh!X{FM5!u*HWY?pb172vN%{F~kScp{V(uP+yu>^=qnR@y3g@h;==O6;K*QEvdrOhnypsCZnB0V;Z#Mcx~8h8t~yp4!|K%Marr%F zyVZoQS8#z7J9;ZG*sY0FtfQ-SdUpKG*^~ER?z(zmcz7UD8W-S_w^}eD06}SlXW?9h z+R_PAP&8CiUp+oGvUzIr)=Rf`uV0y2T&Sq2^@W21Or{i)a=Fl2%I$*34yS_-w3c<+;ySnPJe>9oUuXS_alAm9r}g7H|SG#*Wr z#;PmI27BAjpFaBN&6mIZ%O^j6`}q&wJo*0X&!2qu$5-yZxV*8JtgLo;d@e6K13N{! zl%0V20(4$xVt9@wZv<4QV0eztIR&OTQXympE22^qp%Up*h)U^98Cjp6X!?}E6k|8) z9Y(#&sQ2)ClFi42%=(B~Uut1$Y+RSXZblt%jWqmtVdh^qSH9jFxz%2_7(U(ZbaA}@Uoz?8eG&xb3R?^=R&C?dXnxKhJY_RzoQyia zGiX1>>rMI+qqfANSGhS1^7C*SUR%s4kth+HDn0<4A{;7;M9C~E`Ed?BmC4;JR(MPm z7vzZeN=g(C=h;bo3gMoT86^(X@f9jzs62`C^i*t02}~)>&-0%GOl3rWIX9q-h;hdO z_U74MQnGfByp+MCGLIE-N*1f?K!7FxzXGNX3cowR`CJM9AeZStizf+mQeaa`rc-`4 z0QEF%>L3nPws!AG&ek3Pg5?~UJS8?&uTza{$Wqkki;npn9s&n3P~_Vj0-@aN^&DD`&{oB0!B}3J zF(hCz9mag%t=IsRdL9DxFeJQ>)uR?erO~TtejnO;;C(38AA(9O5k^Xq-M~Y)qk}&T zCnEkxkSG@{$n_$Kkbx)Ebd0g)pjIa^z8yXhibfs{z_F}_chC~AT|K&&>&YE|4G9_4 zQ1fBw#!ZR1bm}xPkmF=Ay8W(TBuIjI@NMDUpjLEa(w3cOTbl&Ug!#!sv|Pk1)rXO_;8*Wx<|07V(2}gyzC$Bt*>jStEq2kZs}-m z8|v%nY;EgJclV^bV&MoBC%7*Jm?GHJ;lufd4ik7Pzpx;$Fdv$9IDu7K73EDyL&=*W zzU~T%U&g#$!q61TJ_%xyEYJ^SjMFoDg7iIe+|&;#eB;ScdKP{Y&NrkbkdrX4AWy`m zo|WCDp2-^7EUDj%L@DLSi1>0yQ)K)mgGW7+>wiwLsb4*_Kd?_ipALkl{!PEBryyGY z4K`JngH1_+9Tc0Q8oiu5H6&9nPgdngTXI3iI~rQ?uCAUomB=EHN@&q+ z3gbZyJd$Pwf6!l1ndhx9EKEEx;|saQ_ubPLJySVy|~=;r#(J2&2b^yZ_- z@4WujYuEO!9^X1PGB#XYR|6{%G3h0ch$th19n)Yatzhv7VXcX`b+q>O_Y4g6!|3ko zZft3cCZe#!=&6G}0q$Ueh1QhAAb4A>w6v=?Ju^3Td~4&ceYP&%`HrK^>kL% zR=LSap=ESBgPy~C78VmyeFTTw9f(G&8ydR$`{$Mxx6huwx_4#w+NG1Hx29$%I=b2` zsxUnbRxS?JQrLR%1fVd(8e+AeyR3lz+pxky6K-=k1CdawG6fqyHa>Fn*!tOXXLc@} zpI@5q>F=(ts|tpLX1t?;hFl~EgtAJ^uufs zKOtf$J!Qoxm0Su~BLhqkS)YLhKEe@zO2g%G!np)HyS%z^`SQ+7FW&m%%TK=e^5X{& z?kz3NHZ;~XH#fq6ZEfvi6BFB~xA$)BUAVNfw6fTd?uf=?#0tQPAYOS{b!`L|CJZM`r?nDfBM1apFMu%mD{7kgKnqGW`ljRQ1Piz0#`*R zF0}sUtptm+J8YqFsI8;<&Yde?|K*c^{O#+1{q)^upM9{lvEX()d7}}1Eur{jB!Ql^ zJLEscAo;Z`NK?4Wc>e43@O|4H_IPQ$ySE#?q&Ai(XD8b`+g)xCk49}KGXcm1y93U; znz|Zt6QsGmxy~E#LaCYW|IIDCEBUM>D|}Yb@Aevci(;e1uFh(g;Nku3R&xGeVWgxP!ii*5<{PrQ3IJJ^9O@uH3jfxiC{!Sz$C=^c-hF zex}Wi7?jgVAPHFA;6HebPouGv9X8VnRlVDt?r6Jv>)M|`e(%Tcp8WXzlTZKj-p0|D zy82p=&jWJ^x}BpVKSvE<2`a_Nc2abR@;ySA(r7cl6fp)-Wr_Ic4H`{}oQQWI4~l|6 z==DmJ_*uHVr(shE15-HYE#Mq@N)#+)Sxy~{O&tVGDe$yx9p8c26s)I4o^`tHg58RD z{PkKTsVuYX9)wLXlHqv1qMFYE?UCC-fvHf)AB~0* z@n~5hS{e&e9p5`|y!72ypTIfr-PeDH@#7C)fBxi?YkSw*yL(-Mu*2hb;ee&VEs6L9 zYEdZDrFex)UdEE0;8DnxA}lEpkK*+5`Yys#T-G4iluibwB)=)WK!(l8IE;FyQSah) z9$x1+p`I>m*2m2Hl!a-sabp7eQfI|qPLBNR_S#P`th_bUuoidrcuY-RbDh_mau^c= z7Z@b6*TJtJOWdGqc(0er0mAH#Sq|iF2a}+42Vjhl+U1cvYL>|5aJm( ztF`D=oVJA5mbf`>2qXOTW?eCZ#^$-eRMyZGWk^$+B8BaFL53WqWK!+Jrl5L-K|w0? zGcV4Qjm?X5a`y@)kg8ZFP30YkP3=de6xfvPi=JQj6ksYRnD1$#zk&>1O5{pqtj_mC zQcuICBuGj@l*)EE&p&*Cpl?5o>fh&0WgAT8Wa0fA*wmo|v8ny&)4|x(kwf`MGQSDE z`9AsH0oatx$ihF*k`o?MGQM)LDFvA-2h)2RHU(WgO87BrPh&8O#QRjrAm`0wy%tIKX6UbJ`;DXeb(nwgUc8rB&PA4u3e{3Ho3g zpkO1m2{6q;i=suO%Vt4YpB?pyFw6*i8RW~aiJ$pCf!Kv~Hri41a!n`B-M{vX7$-*PWszNB0t7_-8(i#U$B+@ac!M{Hzp)RLCoPo?=rvg9brM6SSyW6!bm+tcXofVCwh3 zfKB~A!V3=hXr5qw5io#H|j6@eHibvsNSf*jEH*vv`zoxdTBi%MQ+?(!dZ)~iOC*n4{ z111)f40~PCSh%67erjg&%-PdduV3Cib8=vK!0quyV$p@Axl?CO%*{?!mRC4kPSVF@ z$VH-Lk5Ei$ylGKMaWNTiP8K4mFFzkG`f(hF6`>$sQtW1IRH+#h0$Idns)YU%?OWk( zD2P-d*3vm7t6VLfq=r!KqhswSO(9xFaVj!YIQ0<{DcYDDBo}d#rl+OJ3vwzSHNImE zqM$%lV39Nj9X2334ROr2SkVm7Q`g*Z_R`sx9=!C2Hy_-8^~G0SzWeUuH*em&K0P&6 znka*L)NT_@P;SB`tSZv!)T}{=0X-%I&l{*MD#4~iyHo>Cp}0Hn>29y1x~^hjY3BTe z(=Xk>^X}ufKKSE1H(t2Dw!Ydw*jL|J7mkEYW-~|d9khsH^lFSGhqZ<=noMq=udF=T z-QP7iJ2pK(F)}gK+1;M3NIE?Zlhw%b3@QXQ#d^J(P_{7U59W50U9EtQh_$8u2 zu7xLYe7p&I3Ov-PRn+N70wX4r>1l?DS+KzB4_|BFQ2)%r%);{g)a-O;ce=c)!WZ;I zheAAODD*_J3vzmJVqBw$TT-`t9E@Iur)b;7W{6dE?S^CG^?D+aNE=aLoj!YNW_ITE zne8{;eD$MG-o3oLGdMVy?&@mq>_~Ta4Gs^@&Cj1Yefq@q$%UnbbWb`}S>Z%q9RY^J z<%0SlmW&0XLATFE^=>A!=u&RvQEmrCi$5H0YHu5#ncmpiJab`Z^VIgl>`Y5XM{`Kw4cW-TP9h;gQZEbCWF3YkfB10s@`cfnky-*lz!^Zl1K4unq$KW0mQs&ErfA4U zs6;ZSNE{i9xg4jdOeO+7@hDUU4|Hglql0e0E#0xSwz#;uFfcL* z*MiYvhW$t2$Yf&hm|?@RX@kG%E6}S%1&eZazQFJ zCh+oR&StkdNcw}!J(fJUM2fPGp+hIl&*G4Dd{P)+j_0|FC4AS+FcZcUP74w`O_E!! zHan(8c>V5B#2<|XOG~5WQfpl)PT-A|Tvf=$7aYB&I! z;#i#oOzEIk*W0`XpPkGI+wZ?upJ^a(n^{S=~lPbG|rg9!Rc3axgWpkQgH!aYJrKwzY>xG*n251J7JDLKgf zH3V&RTCI&l&N;m<7iOR%2Z`k6*W+elN=u-=AoFVD*_bTZlB-n_t{*qN+NFr z<}N4zh@1_1yabOz#D?6OS2LU*`U03msV}P;1s4c6nFTXRmVvp9v62uXByk}m#faQ; z;#^^e$#T15l+B)EzEERY7Wu=41Tf8j`8hB}q)J#|?6bn3G8d^W=NoFb}^VtR;c zA!Vybj0=>ZmAt|uL|1r3JnRy9C3DXXle9kA7@a}OVY;^gu9W8`BlKsVld-AaW-Iu9 zD-R`IO7Wz^|2)eDT{N5eooF`ot9`sFcm|=TXMX$ZXCwt*w%hstm+f2rOW4$J{u@s! zSxBC(9GB?3*-{136KYScLLyJ}<**dj(JL2bDi~N;YUJ2E#G{H}wkC0(B_vr-r_({72vbBT984z5nwlH^ zfdJHO@Dd4_5GhX--ICLPN-{%{cC9W_sPKw&fF}9(Wx+!B?Tb6`lj zL@Hj{@`WL&l#ZrX6Rwm>Dx1+*NzSU4p$4>tF&klK_6B^V<;k}0uBDCD^H(oiyM6ui z&bgcSZr!-OcjDCM*!WOGV{L1DV_idaEEW+2L8sRft_O!i6-KMqqn8vdR?!6+SyK3k z9IhQk!C?&qylw5xlT#zdj;~$ZJ$L)w-nAQ-PM<%yvavKaG1S`LlqidPiA5ng{*lyF z1MCoIgnldEVct416f8gE|)T z{ut;DVeW-@PWPrK=O*Wt=cndppeJolcU0HcM&dEA-v_<0Rj^V$5!Du<6|>a>FO^lK zTDm$$CMQ-lH;$hjoUu|PUyflGQGR)exn2^Xs%6p=!6SIvF05O@& zW{1laj>oF&YCF>Dp|O$K#rfs+)rFO%>Dig#k)hVsmhy^ZFdT#}5dLw%!@ql2S^o!#k% z=7v;dDok!35f>@cMu{jyHcJXWRDz_CTxSr$D+)=8!Cpo(NWvF~N5JHCJCo(9>A9&h zXSOe2zPNk&;<=qOCr)nm_4SU94bRWbt}HLj%uG*CPt7kauB@-FZmiEQF7)>GwzRgu z)`p`Ya{mY$bGzFC8|m`7-F~-&+P|BOBtAe3ry8{LUcWz8S=rImHM6*|ys^HxzBV~G zH#j!Z+}4(=stQIT4!7H46=({Z%x=o|GiOCGP>D_9gUmCWj7{-0Bac8*96_asZx4JI z(En9cmJbg0o!CD9$}6|tdgGPH@4xxpqu1};yncE2bboKUJXPxRK{en&mK4o@7c3T( zdZFNvXg`fKdIok7{^<|;;JTZh9e-hO_pLWy{qVzg-hcegYp>nEb$f5?h56 z>dL~Ei|5~b{r;CrDH;zIS(%-B=PE zK=c7H=)G40Bno@)z4t0og(5}u-X+WG-LftBUgJ29Tb%q`@AI59GZ=uBMU8@I5uTJ)VZ9hP8crTRYl9(XfqV_n2*Hg{r0W5~cMzTqs&##xxjg zCQs1U)8BjQ?8!U#ZeF{7ae4+jc`Fiex5o{y7miZiN(*OcEavt4aH67bcwpc9zSHMU zU%GPs?4>gc%kvG54Q{uGC;&|~GstYmxHMRP+gz}0MQbTEsfNP^S+@aZ3BS+V)zy0J z$e||>Z-4gbd*6Qh*+(C}bM5No#icozCqv;daXU9~-eMF?QIm5bkySAwpK~?ewMW*~ z9FHO{h;qSEiU!E;NTtLu3caMrknK!_c$)MZR7w~$`Xoo63Sd+rfGQA8<=;oT?Li8p zQ~7L)%NeB02KYK)ZymwK44&$gIWI?2h7jXfs+hu&^O)k#u=xg4ob5Tb%u~a2DwHDG zokko6D4+oq1F$EIv7I!!rPwacLP7&Jas z6J#|JRvkAoS+lmoqFr$6UyL{Ybbk8RD~n%mj^1cZ54zY^r=iwi$T$rtUNl8LrXpr0 zYGjZpS#(*OuFSlL#Ic#q;sj7_1ut9|bTL?8l zLa0KlGHz5SEZPdIE^N|x^$LfU15*}_%&eB$7@0?>^651mMrl@;v+8oaN~%{$U^@UW zL8r266buRG+s3A(Vm2jMoo^o^JXI>sMemi0*_3QsDxcsql~YFLnPwDAMRF-=9-b5ay($bww&hv#*Vg{A(Hzi_Izk#Iwx3nq;iv;x% z&x;E1Q6aF(r$+P^TF4iur?zn;DS3t zsYSs%dhCe00(Z1V=V?_ASaJ8?_IlybU~1J9(@~fVB{G^+RaVYxrAj5GcBjoB@HyNL zm{O?4E=-Rk@x*L|6|c!e1D$nft$=RcP?5nMU}<5pSTuUQ&Fz5YA9f1pwZTZp6Yv?W zl-{V-NTSqAyflx_PH0H3!Ks*7vNLp%4AloQ>ZF$gbR+?s3lyfyEh4)@R|hRN@u^7% zp9#*t7P~bV4WjKikx?;Z0f1U2>Q({k5X^wq!yt-i49_AKzBFVCmPZPM*+`O-93<_? z=JtD?UN`PMEQQPlo6}|@l4dL1#p5y>u~U!WFD-FaLF`5~R0K&eaOxr04Py@>sEn^**EI)sXnQan7$ zii=1nq!=;r>3bY3DxyG!+MaJ8;?O;D4BsA6<6eHZ8evnIL&xRQ@lS-$MGi~2bB;}w zq0EU>PodIjHx0RiZH-n{gSx5ihK9PPrg~VKuI*cHtf^~jYHV+Atgo&Pczsat7nhX4 z*8l-jS@CufC19%((k)1DDdE*k-0hs^Dlf&4mrLy?gPLOTc#8iOJV==oz46P+%kbGt zI1L!mHkcbp=GMWjqZ{jo_Af8b&(BYfj}Lctw#DO7kH=*tK?X2MYH;Dr z<-RFM$FWi+&smi!iO&-{#v%DBhlRIF2Ft=oEY#Z3GBQ34CC0?`*uYSKYg=neOKbn& zpf3=BHJeO<&8K92E@DbK9}MwAy%0L>IHb7?yJF=P{aZe*ubl8GSpCxAJeiAe<2xgj7nE49*Tv zfG3ji=9Y%h@!_=tE2qyMyLRKkx$`HtjvQKCo|~8%Yi?^uWvW7vpwsOzz$r;XoT(TM z6kiUfJz15guF2Fj)HXCXG_^EkYO;x{M64nbiUcqq&u)fQy^i!;qd-V4SCi@hUa7&P zw>hoxWURiWp?jcbXnc5VYJ6yXq-UVJv8AapT}3Gn8f9bGHtoFA!8rm7*g!ClOeLG! zng&M(=9Xqw*VhhitsmGtxVW~|KRVP(h!zyK9>3RYwHiq;J4YV2C^r#*Fz8>FXdeGBh&SH`LqK)mGnJSCNbd zLg*Dq#mRhXJW*4S{yWMd1g(^Y@8Co7sl#{_Z2u?ydU$q*H3^=e(S6~{ z>nkdg{!q}0mO&QmW-+YdK6&!NqkErz^7hlmcQ2hkJvTF1S6iD%MqMsE>Xm;J_iWI*KB>-XC(k z4<@l-$Pee%rKOouC%5k2x&H3kPd|9?jYp4eU$}H;Wp%N$s}p9+NG$AhJ7FF`(Hap6 zQHd1SZpo;(kDYlGss#Dp=KD=?y_upuO}HCo7QnjEWPp#r?QtcO6$cOQef;RoJ8wOC zbpO_cbEj5UmwUQ9(&;1~W)2(N6NQ7M3Pv74E;EOvW18mmmFs_Sc7I$GM{Y?6$d$m)^9XykgUmh3PJ zrF4wdnrtyK;DIV`cBsz(8*>h~5!U@>_@%KeNBKug_hBj#6XC zP8_{?>-yE}m(~v*gtH5r>>{YTbg(G3grn6$@;WUhn+1Mi45%Hu_Fzh6iJ-*}Gj=LD zJ~nvz#MbjCcfbDfLl|$p_4vxw3o~<5HFdS2XxQqovqmzxp`#Q-#f|yVdn5=0&yNZ+ z5Ju(MNzo=~Dv=V9)DFt1d@99jrKGa50*w>JO#+ybNX0s+Qrh`Wl8m@PTl>ZBe&Rc{WDeDA$CFI>7XF*8${t#SDRP7hRt zZoA8Ab=u5SF2yJD@h*rQ57(1vP1M57P%1?RogdU%GAM&0NJ^DAP&b8aiVjw*B)Tb; zQLi%LP@8osi(X~bt897|RZO`JYOg^PV41L96E|p5CT)vJJ89Eis|$a3V)EB(D}O#d z`CznhG301tNG%Hc9gM1n2XZNgFpZl@@KaP2b`&4tPz|HfF=l+^r3LHsA5{ z*@d4jEZ^zPEJp3ERwiXsM-9r5UKuf}BPLDApbo;eUX`>kRW^+FgByLU(xH>vbaL$G z)5xrvayujQ=#@TJeIDA{IgUbLM-@vV6~-K~I-i0=Qt6GVxvpGr#d zbVoT|6Xyzr<0Z!9V*jXJ1&Ssr?by+-T#TytCca(br=|jxBA#*a+q)>9D$41pIO4=d ziHVZ?O7@UovSQ>;MO;Uc;Ga_v=U2E(C3|)TQ{2aa$|$J0s3}Sb5$!+$g6(E1d8wq- zYPUe4=kd8=dZB6NXIh;my$Vop4UKBvzCp8+9!vs!|6buuYOVOnqyWy~bLQSsAAiP313_es^ zhYfVFlvQihm}cT}I=yZ?)Thy)-e}OEMFWFNUoE;cz;YL*TsE`WX>$cV{%F7-3EJIG zMz2?3x{?~5X|0Ie;1Rq5Oe%phyV+`SVl=iLuWiBqq3yXFPWrHhgb5k$1M@$eGT=l* zOuFQ-CprwXX5pVurE(WR$OREZQfM1hPDo%Gk(tRTlF|~RV3?~(e~_dU*;JW=w9LSO z&jQZ%BwkQgT2@9)7|>M-CLO6n?8r^H({7>pu82>O+W|uriF8o8jY1f;8w2J9*Qr-> zJ$-uwv#FfEsHkKQVKt@2C9p%g>2X^`L`1uGS;nWDhUsLihu>t2Od$COI(B z-P}}PUyE|7smZb4_KxAcp8oER#=07x*CUZi5iOzfIXrSHN|?xYA*2!rRcVfc75u6w z$BxKu8 zRW{+M?k*)BIfJR~J$*S&CB{>Tq$oc6 zD1k?n<#p;&wq9g%*K1$_=5*TvAzwvhqAG*s0F(^PEzM2MjZkf+ ztJ6@}#uM>qG@7hTrqWeS%?;xdBbP3pUfs96y1KNnxqs{E`poP^Z*ONdn~Fq&Za1vz zbubN*a7-ED=V~Rt(k96Ta=x!kE?3B9@I|C-N+DONlnjH3oZ)D&qq}WtZgO$&!t(0k z(#qV#)JR)6sl!d9Z`pgT0e+j ziRVHzFblN}L2z8+al;!J3dvm`=%x*M@B|TPUh_N^z`_|_`=eB zTW4#gCLNB2V7)<1wDh!GA|fI*jVJvkSZM38>xzXlcqkHt*Vx$72(N2)erA4YZgz2Y zbYiT%yAu=50)Di}#!fMo(Q{@}f(|O5N9jaW*vr|JPRypLYq!pTT-O5gMomq&r>Apy zdG6xH)0fYmxp?OEkwb^~F0CFsxPJ2F*3#l^M_WrE;5Ql#B=u4-u)-`wzH^gku2`Mj zZi&VMa8~W=Y~8ze{@(pppFX|&&I^=XJ$&%m@nf4)Q)8`dO_5jxULaZ+k-g#r^0@Rp zs+`AzhsZX58&Baa8jelzx+xA%i4E;3q@qsFMzh}GvenjRx_jE1Tk6x9%Brfw`ug72 zZeF>3>CC>hr8aoIp`g)ZA_j3|efcLw+95boaTo<95Bm)woD;*;orF=slz7Uw1h;B*??~ljt z4aXx@+0^jF$im)*uKsTLC(N8GMx!A}3f78&Kp>q?Ra7S9$%@K!Rb{3s6c1CTglamH zq=^Ti*+`EicrCDGtxQ+Kgs`%wqY=B^j{SQiV+eMD>cq@eQ#=`M zX>XjJoj7&+$ld!lE?qu%{P>aih1vRsI+!|$2c3!bRlx!k8~2D}%4jv4F^11Z?bKii z@3h;KiP-R9_txS4j~?9o;?sBk^3BKZzVrOrwezd1iyd7Zfp8EO!`LH9Qah=ylv;SB z7_}Ho(Lf&_OvwsN&hyxm0HEaCk6l%+EG2VO>MQEO_jZjP30~a zZSU`sNqDW4L@x4jr!Su-8A0^~XDD<(GaHDzl!AtdP&UOy-wI$#FqopsQnJBmrSw9Z zGsDZJXbc}5D*BvO3dOo`*UVr1s=GKv}zJW-h(gstrmj_eC^W0>!VgLsk zz8Q0UeB_LP8Uv0^G27UbnqyN8Wm77xmKRNlz?7cap;Iu$aBRvz*px{}*_4X1DVttp zXH_m%<1wH?lOIJ>OoY`WO-!AM8L;X$Le>xG+x~uS@6Q*PUMzGStBv$J4UJAijf2hD z*(w{Gu;`)|hGSDECT`LuOxkL@zS(8$^_ZtTrd6~0T7~nY>6V{P&3%7*;iHv-wTQLT zrcE1F6()7ms0tgD5tAltREJnqm{lc=nv6|XY1KtdjL)EQ>6LaZ$EK_rnS&|!>Xbgc z%7x-6IjfZDlv2G)YF3v!wTg(5altE9%NRi@rIh9=rnn8##3yD`6i*efsX}Y1LOjK> zDGp2(mrL`#q;?n_i4t^E0=ANh6;l*Xp4e#{o7%mNO%)QMk|N=jd^S~_$EF1J zRIba9h@w7xedOJJdQyS>)Y^<+wyIoRv*s@YCl@Er5{G=Pm!4Ogvm*(_T zytXRGrbPP@%vcX>Tf+SJw8t?XUg+&H+ov3~5>)@!d_J+Qty0Cjy`bwx!4mP}BR z6V`<5XN8KFMG?mgg&K}&u0uga2nH`hB5iVVnFbBO8K`s37PHsqtx8o*OpTs|is8)h ziMi=WJnqEyWCJ`xX;~RA&86kkiVArqZ&W3;;Faf5rd%YD0IcX`0;%YqQohANDrz?% zHwsh=UK+d>6%-e+hO{`Wu&{(u#bh~8@Fgn~-925)dzUU=IsfdgsH2u1{3PTyBTKsAmYs!i6Zk z;7d$z7{V^F8Cj(y=Mfr4rf2kw*=7z$q0p=7=xm;u8QLt1rN?@`FuAh%HTtX6Hp`(P1j^Hb(!kAY)xGzl}ScpAt>$`y;i9~BdlBm zp-K)rhMj9f4+hVU2^}6+G#+Vet{)icn_HM!T$vx47;fuqOIN3Z(U9Hc(4!~|omJ4O z2KL#+8sNQzr^aZ!s>asl;qlScgKHZ{Hnxr*K6H3}?ZE2f^mu1?dpcX?_B!DW5iWUi zonIQBFpwZasJ$&V8=Q=ysFJGb=S2eaY5L`38urxn8 z4d1W+=GNxQR3&`%sN#r&7@P!Un~Rj#ONvOaG+a*~S6ESdb1l)6!08pIMh<_wHRjf8orNCl7Akyt;mHwZFGJU73QXb^BsE8+w69KFxc4KI5;x2ytcA__|V4I#>DhQ z8wy=29BvnO@sr*we?t?@ zQ41H&oqF`(&in7a`Sn*H-+J}xv8~O%?!HhUZnwDuVIP#1MtC`TR7ViYADvFHvBIo0 zEpba$>kMot9O&t4Kd^7<+U3))Kfd$jXYYUW&Bt%Ocyj&5g#!mxT3VaDUJrqpC;($9 zFXBHG!j7o%x6sR`R`bdA8ag68GbNDpa_g5o7SSY8_A72)Bb-kUcs zJ$Z6#b91esvBu%BWwVvd&GpG-9A*znb!eI-ZJ8u3u9$i(P{%|v-rLi$xv_TV)|D48 zo;-SZ`>hub4sY)3@9nIsO?x~J*nhN2!_H*|#bv~ApKsVBYJB1}MdBN1v>cIK!V|gO z?sPWY-PbiVJ~TWr+}_ja3HV?Q3{#dGF)SQoMmW(#)GA^7PT_nhg3ya4zoH8$~`=#8Y;c z9af&{Z06wl>YY2+-g)QA$Dh3Y_}QJlfo>v{!o@0$MKhXAR3Aw4_%MCXhPi3zgwMI+ zTg;(=zon_+*x`d8y#3_+Z$J6ryU)J);{6BrUWNUKbEVJkGn&nMgMof)7@{pCpB%1N zm4eT?(74CDNGWo1DdJh7$hGhBRO;oadE4{#cnl?>0BQ&GD7ul~;4iEn3jWDGLYXv= zP35^x<#8(M4ma|ushKBLwxt*I?m;(i?bBhfoI&9ywJCI5_UFdlp2>K(@P(>nIm5OK6 ziJEL;pr`HR(Sx6U`25!&zWV7epZ)OdXWxJO#h0Ib^45zN(~HZM*?N~h?DPhl98mv8qAJtO3gAVZV)zQBy7q|hDAq2 zQ>@B?Yzh@qK3475t3rBJ+{9$e+BPGz=rOnlA%&S+1SdE)e znpNejN~%+q!!WAKojPT}zy$Sbld4>sb3QMp>3jS@vni!qqJSZzKXVL9u@jieu_@Zk zmxrfBaw(ooNnZ}8$|XFED&yr++f-FM`Jb1FrBK_<%!@?8N_@BN9e*W!A0KjN#1|Zx zD*i1tRl?z>d~wciu_^BU1#IefqpCv6RI+;q?j%N4+y1JE$ee^*@|0H`GTQNxd2e$u zL@LU$sodkggiRIg#HNb*?QLu-w=?-of?Uhqc664{?sn*xBz9r=X-Y6vN+OZL|CGXV z-Q{*dxdAJDs6-H?C}cFi4lR-tnxQoJy-QTF}{v%)KZ%puSSXr35{!^ad>jIOOsGdqIT0nE{?1>H??NX|bE(*@*=N zvMD)%S9s+GzN(ChUZUkpDs)&Pkytvd&1G}>;BPJTMuP>GeOTtG$yI*6+29NNYntkY zCr4KHt!$k*diK)!ljlw!+&nZjH#;~wQkl+#V{uf9wIq7kh^Q3o3Et*hn_dy`6IGy$+AWeiiCXpq z7pZ)$)b2m+*)0y>%O4^k7HJZM-NXMR5(#ScQIDaAPe&q^l%joE3DTI|TstAcD8i)(4VOqUl77X>{ch z)#lQ&Qb{TQE10j!D6pbZrIHdfQ5UnRTwovVyyMu^4jL-rAGI6v*9dxo7sauuvSI?P z%F**#OV6wtC8H`=q5?xAhjovn7$&>oB0)X1i+E4Hvinbh)6{RUssH(xY--0;zL$!o za$S2In-Vwl<%6Rg+0=jidu%GtuIhKODRNm;Cc}Ydr!rVfa>;t|t#`O=kyt2|t*URT z>mTat8|dpF?C!(g1 zTU?xNZfd{+7MJ~aoe`!Wn2XSO2Pv_V%j@L6yb3yS4umf?s-s}FEtkM)8xAp;GUWhL(B=$0yE#ib-<6XB4YHt}KWba|d_l&C3B zxM(ZBCD&*`p;LK|Xb}cQl0D&JB@)iFj)W;7m{Ma0w1Heew^*@Su|kOlH^S>7CRt=g zl9%&=r1EWp_GpmzK`Do!fcHtSv$>p^+U(-m;_dr4Z{E6o;nLaljRXAy{n_fYKj5`k zOf(gmN^yvdHm2!e;Dt_2&C+?r6!ue>E4Z2jCf-zas;;SSV0d8b=*BzmJ$wJdx6YnB zwYW4tJ~7(T+UWDUpk`!OWdR z6i6NMmExZ%NKrtYJ>dCuYM9Tx0dHMXZSP>uo&uWuaR+BmwoxUx7rI@H?MT$M_Ad~O3-w`+yV z$9lAn*3z^uv{$ALLGVdgT^?_|GTGJJJvldxfa~bS#*srSt1Ba8!wt<1;dlf-N)0_+ z(VUzgY6WQkQBuQ3KItiMLjY46O-}JbI`~lhW_8$tkx)&2?a27>+QHTJ%>(<_*X9;y zJ9|14RY`}-2?r8Gf=+0;Er2zSO))t^1s~T%EY`^-Bn{tJs3vTRyWDToK@9~b)>uWX zqq}2q@8XFw$2Pat_pR+ca(Ls+spIF)o_h7>)idW#t*-5zotxdey7$V}ORwF!aqY&X zLz@Q%hX>Nt=|Cs|m6wqu!1YB@hnPH8zY+POKl^Ja+2D z{*CqV>8Zw+=3qEPvUIt0K%GvPuX@4{OvI*`?Sx8TQ@R2+rQ_KY)pF}KP*>WWs7r5b ztXo=~zWM6KkKcdu$G?63zx(UAU%dO``Q?k}hKC2?V0L<3aE^xW0980?_-H&K zGLP%H(Q#Bt%|WL^HkHSz@`hTIXWGmsEmD6oEgFi#I?!r0H8s_49NPQl>-T>7@#}y7 z3d* zcXb>&zIAZ(V0(8vOcC&o!9y^3@Z+ZoyJ&VedIo#D`?~8IYeUhX#b$z*p8*e z>@?b$D+KVVVg0YrC>6x}A~&eLIq#t=%8ixg`<&?YYxQ!Ia4gM;-0S7qn6wJ=W%_Mn!Cj`p)HKmKc3S@Dze6)J-ue5t~xN$YWE) zX^Lf(Vlb6!=p$^(saJXQ>VRGy(yJn@s?x+X8JRH)b0*{ed|%%`Z}0o{%H9Y4*|n&> z)23^18fu(|4C&^Jqq~$Q20t;FkEt**RaU0nVdx9m$GnyWCwthff6-g@)0vrHFRy;J zF?ppi(Qin~E4U*vf~`tEsl>svU-yQRCApoQ&MABhKg8$|tuoa<^6y zWEnT?yjrSPmg%sYkNBT!;Ma{v;-tK|rI%)${ z3aZSpIjkLFb`@K-Ps(r$N{`b<`%!)1pPsKH_|*-WgNRbhw{x>2DBT+fizpjK}&wDopuojP*o z(Vcsb@7;TJAI9DLckey8_vqQb&&5T_TRj19FdFiQ15S_A zNCaAXG^%2eMB(KRsO}_`xrvb!UMo@2i$|OTBzY51k^y@K4`qfG1r&@9n>XZ_DP`2N z6bdDhux+;@N zq*BpDB3@M$jK=gPlSC#%0afuH0^)c!g$aFxO1<*moELh|X)4##wslFp_rtd3NK-Ch?|L-742tz?Xv5OQ7~kB-o22gmm&U^=HlK@~*h3KwvHY`myfzyKYD{$h~tnBBh9d1S6&XQhjJ-FK-f|z zlT*c1&ZRuxT}lZ1la%kIiQ?A7GVyQAhz^TNq+qI1Fhs#+!X6N-iF|oz2NRT9*sP~g zQd?TGGepS=LyjI<9GgPNTKr1WqC<)Oedv)6>r5ziBJo&zSLf8i^yK{1!06D>*l=4{ zYei+8bU@q9786O@QjsMnt~t?H5GFaeAl7aj8;TjI$Or4#}=06 zuidnzOI^v z+Grx?M4KZMwi%*LqM9msIO`|Q*@m`kXy7p&UQaTUY3=SBo}8FlSw672vH#G4nZ-GH zlbeWC$>Z}_IJZVdO=@VNoIw)Bw~g}$FyA4bnwx@smf$FqNNYXWuv}BT9JVj=ZUT5?ajGPpMn5B?m`kx zh=bP)^>Q#2XlSgRotZdy?)dqOXRchmc=Oiv$ItGaKX>}@#`?+QM=qQ@b@}4C+qYkR z^yuDeuU)@%;oPyKThr5%)zum7z4bcmPAgPiMvH;=?$Jh3;`A;wyfB34pjOc7amSL$ zw(hR^<)yWQ2llNWoLgGzA0A4k)4ov9YPXXZM>ryL0w=AWCqH_I^U9`#ijOB_#8&6| z4(B2^h4$v?qlGC0xF>;7ps}fLVR7=>wKLD3-hJ`LqYvME^V5&te){O{xiiP-X2)Av z>LZZ=oB=U+j|3_5p?I1+=N3KJa0fq)CIhUX%&3;JkOi2frLF1Mk&QzK_l=K@*3{Pc z0zNcvHyWvnwTcj3jVL%z^l1uex;*-%<_*gD4PKZ~_9jk~= zOb#DAv2p3j*%POZo<4Q-!TlTO&mSKh9gM}IT5L>K3fdk@usM@+6}Qa+G}4Mo)^gb5 zilH`6drftAV4!bierjTFqN%N=y1oWureV!VD6T@Ogs(%aBG%R0F}pO~+1C|I#^4QS zNmMlL)q<%Hxeg5@GayWZrLw_l3dKXC6GNA;oPYS>*6lmj*AMNhsmb{LK0AEYW|F07 zgu80cREnfa7|h15-mdwjxy`NhYd0=_^7%XW9^L5dYD-jB_yS(L!)`Pgv560k6f3#~ zvZP@UmfsfQ6>qg!(5MO%IrSE+F%a-hObp$)dj7+Ap8xpQFMs_0D>(2@9y>nJ-(QhP z*qtucWI`i%mM}Fv@=91&leZBEJ$)!tgi4WqG(j#!FT56x?LOyuDx=&jJNlMOa)XCa z0;H0P!gY+9tP(X0a*V4`TU8*q5?+hY&?g`%`V(!> zEk=ja&Kh;}3cJwcsNjcE&B>BgBL8#2U`lZ6V?=p;Iu1;6)>2e4MXZ1gCMzeGLbr2= z6^6rQb9f*%x*Dihg#d|+}_t~#MeD%+tzJ{OQ|K*EY zw{OiZET^j*J)x-G>vwp)4!7IpbXx52pf;1mLJWtE)P;=rr?E7jl+#KH3QR8JGEXbT zHS`g!6b>X*N;qR{HA{cmGFg{f8<&gKoCPsjqXeSvyNbQ!x_B7d2^OW=+Dx zWGp&t?I`wuC zO_g&JsbZ%FBw)g1e-65Y`?I4#b z{T*zoq%e4Hdt2W&`zhk@l&5Ig#Um!s?fC#I=UbltE8$s0BB(uNY$r>*{w13dq%VSQ zYKQxao=b3=D(wCf?REi+qn&*Mq$=S)5$qb1p=Jp$I>UJl7GO}PP+=0xgr$WTLh(M=IHr6*CUT7%wXw~S1VoxgJ7@#~KtJb8HU(Y@RE?%ck6=gz&m4<9{v z`uy3}(PPc6ZT?Wm?Z+@dbYd|ZVWsExdAvcd#g5jgu=dapu%=^i?xjwKGQvRMG)sMfqjmxjzy#DIVYr|v1 zZm$PLT7*r}$U@Eq{ZIcb9z2`+BQKz$Fls0B^BkMX8{DtN7U=)|Z?LJI2-WtGzW*JY zdWmkTyts@D*Fz_Hm?GdShE_ANaJ(v+smrEovzgj#Dx0cIC%q&w9O^ZAx3k$)Lw#*` zPuI-+%>45F;K)#CZ+BZ)2NV$%l@_!S`O=b{pN zTGyjbxJpUZ;R=4$jdTMljd&tHHa>jh$i_U>kmDmgy&ZM+)ppFOF~j#-4$BDA76(81 z9?x<@jR*pweS9KsC~3Y#it~mNZ*U8EL0Bc_9*wg%#|aj88xcJk^r6nvg!U!|*1%oI z)S@dgarag#b9=7{^7pvfgU(! z8sHJ?Yf`n@%4}6Q9`**jP}yO;EXO6d$U-=ez(fu6b~062-_qFC*E2agy|B8pxVAL2 zG&?pk*45XQt;yMTc4B~Mo^w$T@2?YIJx*jzN&0hb4Sa_^!WVh z^74Vzg|(IG#rgh`;rgbAid51U3OLT#DF(DZs){a7J9_~NC!7Hx{ zQug?)Jz{ds@ODyKV#8>*nQ9uUF@|7m>Ey|+dv~tgxqa>AiDO5PZk;=S=E0*o_wV1j zdE@HcTQ~09x&a#(&Yd~Dxjr{D)zjTsUsn^0Mc}xAH-x3i4py*iBK4Y%185jKXwbsy z!sT^UrYl=JT874krWfaCm*&T(r}~Bm8(UkFsVZMEh!*rFBZ~ZpEjATIX>uREIJ1&r zc$;@VSB0}?66>b8{o#FpscSS0Br4JH$VmT@!v}8Ny!7^455NBMz0W^+@$B)vb7xMi ztt|KUbY?SEp^zV@FSJS~5q>Of4T2o|+dy36M&ihoN>D8e(5Y`*e6| zAL4H6b`HgBwz_I{ZT|Lam*08o$>RsNu3kR3esFDgsIMwj;SYGsW@OOB`(H=mDUmnA zyQ(5Y8b0Dc(9_w~ys|uV`O4|Xk8i#4#{C;N&QDEER8>|rG}fjwRX)EDUa5*}%2RP0 zDh{d9TX@kRu{c+&h%#2rnvHOl8J!q9w7Gv|Y`C_eE>)MUNGE9%0ep7!Z*_XTKj4SS zr>U)}uBj%Gs_?>YTTNs&$l1G5jh04eR$?`Fmo1g88l4zEe)7n@2d|zvePVuYs->kN z77yF(Fl8I4I}kyvEWU?Y4IBgMOmcX*|IYoJ4<5gE>df(p$;rXtfzF;bf6$MTezOUC z_bjB3kI3(dqnZ(JF_XqUm?|+^0hY&RLo6EV@9R3cb?~j{55N54{Xc*G@ryT}T)KF6 za$+o-t?~N(W~)taG-`O0b#2fpRbMs%caow)?BqayVjP5rQePu=vNSM@|i9X_p_#RS^m+F_q#bZPIDZ znV<8Gv7$*vl;3J3Q6>~`l4X+6!Dn;2?OvbDk70bicsy8H8O^2>ovjTsV*@9*4m^MK z+P7c4`}1Ev|MiD2fBoU>zyI*{x8Hnn>B_~yk+G^woi7-5d3|=b+lKB^c1|wESxXrW zMgym5WNA>TFbxW9O2fD874-2@t&|c5X?sOBrDb?FMHEvwGzvZ6)`wt9hXX}ZS{!^g zp9Y<#^r)C}qi9MM)N8_eb(~eDOzI{RGi}wr+7|!f@Zdil9Q^Uh!nO9wX}_)AL7b-S zY?W0TYwK-nr^h_%HP6}fhdt)I4Y99R`~P`)`Ma%&dwsR5QCE{u zoiwUqtRi7lR~XfCgNlNwj73{#M}KwLh!~VEo!p^U*mVjtKUbH#v~sUb;nOKSTBSve zJW8)BCqrshN&T!k#Hu|yrCB4>h*SB9;W?E{QFkfY$EW0D_!I;{y|jHVw_TE_j}jv( zu9dHtH$SJEsN&p)2pn?cC5O>f_s44fXqdrM9=B6>l3Q1pw-05~-b(Q8@(^VN;@xydqJE9@!}TbKZ*T z_o|_`d!g?s$_q;S%|9pi%;R9Y1&~$D`%~qcO%?PW=6j?I?_?=j7-_T^ZVq(~EE*ZT z2C8^Dv2%g*4mO6AOVHYdWZj~T5;RgyB!IX zLkC?mYN}xkUn(tCF-oJEwb)GXzQHNO>a@c80d^7!UYFPH_PJrVG5U~E6I&#%O^+v0 zsAb}a6NcIC=0s3p8I@QfwPzQ1P;rrb=wU8y?&JB=D`HNyYYz_2?VMn%UAz7V|1e)P z#qR(&N=l0*(lR*1!XW{xT#SIR;#)1lb|*=hl#8oFrO&Nc9getyA)Ci%ak`C8 zCzQc@gH@wpq5Li@Bkgsi!~=?BQ@m)ZnA1v$&A9Rh1!!bH#d}yN>wDb#%i}f2?P$belHa1R;x7>3bwbmOiYYTPEIWCU0hmS=o{{>YpRPS zVs5XSauW13U{u(dAw`dRoJJUtYb&`%nX|~?9EZ?r2-bBzzo#M*%Vbk^bv3YIwOP~} zA~#Z@Bq0|CDosjQ0VOC?gdgn&@$JcevaDi|*c05K@kZatuG$X_bNfZ%qa&g{-=+Z_E?Apdi z3)&f^g-Hw>0I7*?G#0K(ClZzMXhkFv3kAbLo81QQi2XF6-H}D&g^aNGr5lLiDS0g_Q6ptVW@{ zh1uI1^hPV9RoSYV`s$XB=B~cZ{^5QYP3_H9*)%+(-R&?~OmH%yEl~_7b!l{ZyrZwHx}h!*37aftt|}*8 zcuJ*0CFDYGCsDj0N@(#@YYMKvt5{ZNvs>X?R*_7!v^DqicaKhtOwLS9&rJ@G4YhZ+ zWverxNYLT3V>m3&ny5DvH7yrf_GtSaE%3E8%Z%Ea>j|!bcTdkbJ!HS+buU)=y=ESkX zYpctn!-I{DbrrFQ(`iQ|eS^+`O;3m~NW&D9r&B@?a6KHoE{`)D3#V(+9o_AtlcVq^ z&o0hR%uaOob!Td_!3ai==~WDN&z(88yfok5))tANA-N77lc9Ae znvY?EAHGatDn(i+X|?O|Iuprg8x)vR174mxcin9>SVO6beW>)li5Z&T@%=H-xzbnoJ_$K`QEqM=ke5syclHd}pd zW@&Ni?5VA-js3IJ6K!qH6^S@}UIgqg$l_Rd$rx7266-lFc|W20j>kit9Zf6C)7P(^ z{osRV@4oZo;e%H%UO2I|IGs!;U}lFsrdfL`t__MKQED zYcy3rvPPD~~ftdfvQ zb+$LJF3;b%df|&t-v0hCpTGOg>o;#)US6DUX=(9zeFn1yJNOI+z0rV+UUGO)!*e>l z)2<3dj!jXuk6f&k%4bv3oFupqOyz8vqh#Qp#x zHYLepQ)KWBfPCZ%K~j=Z;r4%rO>uY%*_4c9Q}9-()k@6cvlvWf7QW7MPL|BKRPe@J zdH(038C#gNDb?XLNTgMnf+=Ett{1}iOahpKddfyS_-roH#0PVQKi~<4yoriXV|{95 zsB>mw=lQ&GJ-X;9agG+jo`;js0^Li3N;=YP4g_UVDX194}s)70cJ);WyTcD9ms z^O-bJGZVL9H(%1s)Y|mzF5{rbJn3NfTeUZ{!B1w|emOPw^O=Pgqb(Z=ZUV;v-)QCg-E68*BK3RNR1tqm z(eAuk#G`~`Q@p*;|AtKo-05GisXS|`JfW1poqn552~mAwHbuc*DPdCvliu!t8O;dm zNfo0ctt*mpVvB_CCFK$gauqYoNaX4~F56hM$sO=Vt18Vdhk{%oLRU}BD^WusMtn=S zR1U(Xh{p)_+L_~iA+kDfey_~gNZ z$M^3)y7%DGy?YPtoj7xHczm>~I^*!TjTSS*>J(5EFlvL@V6mGuL}Cs52K$f73bepd zQ8gD-d3x^RvKC&BH|VoEtWc%GTM7$uI7cwVQr_ux+FUl+RjIrj-Y$60HE7C&ZD^EA z2_K~hI=#ZPshl86U{fNBC1O(rCg(-D5IymYdw8MLt~^3TRaJPS;C#NjXcxLRNwF=C zWY3{u3QxWoRD!|rKu=HbM#0g79ehRTF)lDDP9?RQM^bx8VjZD9MI7+Sdr<-b;~Vbw z&~12R;v$7kJy12LtFurfPR`B37@M9Qothn)nje{+8(Ua_pZ(*LU4x@-{X;FC{dM)- z;c!~7x0azyha~6`HdWv^wG*4#y(63A@e~*Tr_rjKTN`e^cJr^qcy3e9nKPp)WUd2A$1eja5YI8|yl{I~rRX>zW$kl}WeXXLH$2c9X;B@P_@- zWIS6_-O=6E-qo4TWU`se@bKW?)#bLmNKUN#VU^|bxMJ~GLqpxrP~XAzwUZ~0oIihZ38e@bSa%TD36{#s z%gY5ra&AMy4{3RMzE-LbPf7CboNM0`r}goDsWfz(>k5=BpN5!clNMXyHw`ged6s;xcPna28epj?2+}Kh#G}gboy0Ce8{rb(zcOKlje(T!F zb0-(}F7yocRb^97uZ!|1(hG)HKroHVY=r#@MZz_8@aeaYj1Nsrjd%BT*3{R8V-cv) zv6eYh#74bxLdX^+tJ(EJJi=d(%;(ER?|?ENG1Fs6drJ;x|W2* z6IG9n^bn!PyUlEI+S~zOMO9^8b3i*RO8wb`7tWD2NcXfBBvnhYj3llrM zYHFyZQ7eUto`&C184t-*V=Pv)$LEPBVhv68J^kIY^E3MntR31|-?x9?)ckaNZ)YM^ z>GHauN+o?ms1p;+a>-ES+VqqnHbs~f*#V*tQIjF)STI)?MPHZ!7YWtY*Y@`J;8P#m zx3ac8Jv-Sq(4DPGp#z)QNcu5(HIy!=r4ho*xB{Fw2oYlES?i zx?Pb-D3h&fX=&)}Y_6@&ba%DxU70_5a_iiMlZOu<+B&j%{^Ggo*RS5VarOSa*REVS zw}0RA;6QI}P1=ucO9tAeM=Kzfx=4|hBib{i=e&q?Mx%j-5hSaUO|4BM<0H$f%Lg|O zEUqjJ4EMuf;|uuE!kuDIhC!JWVN;Y)aYM&#(AOv+De_9Sg=|V!$fj_Ah=c$cnnCAw z+Z!8e#>NI$mgbLa9J+h+#-|^>_~?V@_ikT305e!iV=x%76BlbVw<1+1?;?eESCmb0 zpoY~MO-7&3ld4J#_IGcruid|M{iFBZ{PNTHKl|w2ci(yA%9RUnSO$ZBlgY>uYavty zG1TsfG%9iiXS6X>aQ{~4dfa%ql*m-706K}g{FMApg@*d=t8=l-uuO7!oHccsv5BG0 ztpn#SoLF3(jz_`)pF3F*$y6mBb}NgsmYM{8YDqT`t+)x9LeF!od|`3u@w%#OQpb-S zeB;^e&p&zV&)vJ(l%H(8VyhetI@g~1F7|_-fFW}rIT$P&AkI%^-XnlmmQ`K z700+VBxY1CSX#mH4=Y<(G)CfKSQ{KWdg%3M_Z~mKee~EyS5K!u;5M3BJ$0ZbU6}+) z>8K5b-R0=+?K*L4>&4qo-hKD^`uhGX(>oO2bB2y9A(r*b`gVotT4O>w}DD5j*OM^8=y@=Q=(!S@0!r>MCH z@5Cj#vLNc_6MxGXQ7Rv8QK_Bg#hm(TAChP>gZ zFI5?7ZOY6~4!nBh_@mob-+lhzFJHa))AyhL_}wRe|KW?DfB5omfBowH58gR{=~8t= zn>SeDBw)(v_S(^4%5Fw~0E>z1<70DSdEjyubSi^ZY1DFlQ&wbC2&O2T^5|6o1F=A7)hUCz$*37KsBd*td~y^PXRlXscwwhH`AeB;87?m-DG6w%-6)BUZ!C`2$vssHaWde7@1F}2pcpWtqC@<*L+t$HX zQkF~ZBX^L%PL`rmC^`*`s1yZFWjphz-{|Sv!B^_H$M3;bVkDIhsfu^V(JNq6yYk(l zcIAFWxAS<^uA(Bb<?MJ#;9eO3E^~u>2E|X#W$o#;e-XJORK{MOAfUboBfSei#y;C#G{PK zAm?knay)He4JcDciB<}&MX2vLQAsJ$(p)Js*$fPeS6~fhgTrluiW1JqT2jl}*vEKh8TbtKe@2)g9xo<~&Euq>o)?`qG(;4BvAB8x{$+`GWk3(@hD3_LtF5zl4_+36AK3`FS3UD$4VWqV7orO?<>v zi4LygPZ)TpNQ#jPGAcRDm@vDQ6jL^(A*Nn%JjlqR1+`M8#rXKdM16OjN{Vmd+fCWj zE5bK|=Rdpm6y+pLf~{6Djkn`}B2X$Vg*60}ob!uwckkVP^yJ}_=kWiJ?>~NY|LK#* zZ$5kS;*E#TpWc1^@aDaHS6+MV;^iC1j$a-cTJQyuW#w`bpI2O5$}6%6o7$6OQ?KkP z&`Ra}wdfx15`$v;CDI$TZ5=JI-Mseh+poX%#^bl1KYshoC-1)b^!*pl-hT7-)qQKR zL=qM*MWscY-xN*gdudPKOWD*Pe;=FTU{t;r`X36})PKH=P5ogfHudiZ^Zo0FJ{XCr zL@W`D#v{m=>~>h9At$jIO*S*kOOa?8O0AXE{%kwR5&GCx3FX%TI zVaifttDOu3*Qmd)LM~Ghn`=y*lb4e_y4~(cNnvV*>6EBLsiip-eNccHFb4`2vP!Nl;C2lM0aIKK zodBlfWZnm?xo2P?Rh@-tlU#T;8A-C90%mWeob;HesSZlT z7omiEa5@3f;YFJwRa%3VwHV!gPgQlQcc^dw#(`@$F2DZfqYplL@y-X&Pnxfw`sG@#(Slo{p+a%H_rRT&Bb*Oj`TE zN32p3>m;lVRVt_^%|>r1P*t62?P?zyAD)<->>28-uCEQpqYjTtM_mfJJUf+^$+`F7 zIf!^C8toQuIFPQd?in3e+`qE6d0>6((1DHpQ?rw8?JX6FI860$I?xeC6MY=I>Q)iE zb?#sz$|c%p>2TRYkzjRgc64%hVP*cn`o4{=LkBkxOwUbsbhX0)1`i0Q7aV)Q`j7^SJ*Hs5X zD6qkcKBUW)W~=cA^(xU&a`=J=Q$!<2vIRMdZ_1{0gvsd01uPA5RSMSBR`>RH&CN|8 zJ+g7)_~FfseKRxTElrJySZr)$=-kg7@8`b{N zXXFF}q_r(?AeF)mmWA(y$?f$dt18>OJLi@b_N^Z{xVgTxx;!*8oXVta4marVwyh6WvCbF@+pFFu~A7@r)yeC5oCAH4a?PhWrg&hnLotoE|rPi(n4L zu02+-GnzDdm|c;sT5XO@ZKkKMqp7(z81_;9Eph(g?Z~tYm+7E^HIf1revDpIQCTs& zFmvn9jjz7?TJ9v+32n zORqn@|MTCz{q>jc{_@SIPafXcyLZ{^53oivjUvErtdV69BWrojb2aJUBUfQWNGj(j zMFEr;M$sWFXyTLPF(~YJBaTcwn<6?W!hARnC|V*QT{7^qpwjhEjl?*<8nDe0=Ku=xXbxNV+J0C@CO6&nB zBw29kJ~5c$*%Wm?&u3FqE@iY@O*Wg^?yx!$OxZnNhtKbZ!!;cBN1~o=CbB#`c>C(f zuRePIj~~DI zg2ik;3Z|ljQ>D$CMhDyMHdWhnF@wsdmAgqcpG946S4rLKa=%tVQu*W-wZxz-Gbp93 zTB=h@V3^hAaOaps@6st*l~kjUs3@BfBPm&#Qe=C+qg+bd)|Zc@crYc&u_>vv`2W)O z7T#@K``-6j@4f9gw@qS{#W150Gg!7ITV`fvX2vixqmwue*hw6RnNv)g_MCs~-M_tO zMk8?A^W5j@+VzqlwltFV?ERT9;33GE;@K1dP~mJU%Cd*U(*FjVO8zRF3c36e5iNnFaLE-LUy^tvwV_rj6bu!PmDnFh_s zHe^%0ooWND6rqxe9{&NGijA{k0kN<&swjISkxLOa#rdQX65`O=gwa9LCWwFVxh5$E zn$FPXg$UIPMk0{tSm`anWpaQ>A_XVfb3v<6!M z>^jtF)wn=VinbN#1dV$PAJ1g6EZ!fAS^oDUNsa@$8$=H#lZzEfDGriSK>8&l zqAM7KF0UZZpXmn|22G(&5ZXJVy(HRY8_e)v(WW&iIZ3LN5cQ$(h;yxw*;pwUx&Y?mmCE{_^F+m#-eZeEsOn+b3^cK79M);al|a)x($1 z*WWyUa`)ES^wf^DK)y&OgUK`rhoVE{VJNq412!eRt1;LV`VEQ6@#vM=*j#t{@`c9_ z?mS#yeXzFjaP8Kkd$*oHy#3(b?U~tme^ySCNDT0iJw#kd-^Of;xcMU4)IURPDyFB8 z3z)(fiW5-9WK-Wpv8lgeO&hVPjXL`_22i%GG^`_Vf+*lvkJevog>YTZe5~8ffuDzY9HKGPL+Mnk{L5e^E(s zV_Q>ePaFDJQc;$km0@<+7|`^pWLy=L6#Q#2@YQ@cRyIom%IpuZL&E4&d9j(<( z^#x@mfxK*o$7QgXwR#R&#omA5H$vo$Z5@qm$carnk?I z&rNppwO7)%c&27?5xW6Bg4#QMi)PGj^vPZL2G*tJ*s|hDL`cXQt;C z=EtYTvF@uOzbN0E?nN(n(kqA4&tx+8Max4cF{yCkTAZZ#Q%SgVio4*>K09!)&{0LZ z6_?wI-bxKk^#eowqZ6ZJlcVijZ57oO!MtoI;70=yII$5}GfDY?h10Qr=_`xpjvqbHTHjPtS=rIn*xTJwRG0@|JDdzd zYteFr!aGf%Qd;y8TVwD`R7p4zx?y)(%E}8yMtV;i-@kfm>Ft|mpFX^L`}*nK+t-gB z-9I?kU09g!MGw=U2Y(_aQEa5SiaazDb;Wuxg^W=VZq^I8?+J6xBZJUGeS9i8Z{I@$ zEh8(d%jOm)PoFvrSz+hT-dwtL@$B(k+vl4aYO`|!HmjLo7#uaviYo+UOim;^=-EM= zUzf{~m!CU0*tfWN?!~KzZ{I$C^7!udZL^h?W#|P)fpQLN9e7_yIN7$4QwW-Jr zbbr-qqsf#R47Rkk^bZf#G}H!igEo(wF&gBQMoCi&jam*pk{YzgQ_Eh}0C#!3!QqxkccB>gJx)?3=FEBKknkf@BI4l<(Hq{{qgg=FF(Ec{U^{$ zefjnM@4tNb^x^G+BggBS+fxHMc2BC!_)- zl#*z^$R<9nkB`78@bM{Bst}bTf#(r~N~2_Z`ZzEpq194gQ)($1I<-s?HU(gcq@X(} zxto%w(uxeNGM7x2qNG_ADdvNbK}mwN zv_P)_c|nH0EVs~Ac3q)~%FxO@l+39CFlAPXjk08iQk<%hrqObnN~}|)XmS2I&AR!} zry`q5lB!kuvN>vD9oI#(u>~| z_FbWUFC>WC6g%$eZ#($n{)$a)0IW8J|G6lYlz^D=KNj187&=5@J$?LhhfxxETgZie zbcPj4Qqa!GXf;_KR4P73SZu`*c&*CKUVviL+_LANzJrmV7je%svn#q(E} zm#*Kuc60SQ8p}7YUAcDo{NjbK{%&`g7oGhrPAhB)4GhkNSK?49IEkcS8l#0voN$7$ z+ASt1WQV_)ou8AD6)@Y;fil}%PIN;F-9TUiM>96t`Hs)*==K(9eA~iR)Ny5e+^YpA zgm2<|_cli*AZ?E0W6#-_CEvlvw(mvqpKxbi1ejvK$g8I|#U*Tkf?yD$z*Y-w3eXuX!ITkd~5eCJ77%=7JXl|OaDVmjqq{Gj-hc6E{r;`xwHuco+`jhg{>@j9@7`X% zF*Pxp=Fb)@6iIlFOGr!*wDpm{5(+<$oj1ib9&#EsJiTCNpU$XjZf#szy7=Vbormb2 ztlfHW_vZcE*Pq^By}!0PJu~Oe%oB;F=#P=mEyAYwm?@4*MT(|kdir4eGju~x(iiFJ zBlJmlJ60C@*YFhg#sA(IK>bBZRqP>PQ)nK@%=Qj%}s6HF~4iiwuP-T zqhmwez3sL2Rax17m&=a!eQ4p0b~J3HEtafEIR_suY7~LF3APAQIq0Uu%`439=xQAv?(6OD?CS1lZf>lqu0VGnkmX0aW3&cC%PhzY$C2PTFpA4F=ctsR zI4?QcohKNWO<@v6G^j90iWHt~`CkZ^{uR)VfF>N6$2=~J-9qVT7z_>GD6}j?vm%i$ zsN_-C+!Tj8`%yg&MZ3OWQ_{2j2yjW8tCCOkq+F&tyGQ4>u1?9DswaxX_jdf+U zRkc?aNXK)~KR@92nYYHo8;YIR&}pH5JY6Exkj1BhzD}(-VE8 zgYCVY)r~da9Q3E6b06e^qjQQda)%9ok`N+=18_A{kp^%V#c%t1x`xm3h z;PyCka)XuC6&+pe1H=7jw0EI5QB7fSfj15J%;GpQtdGKYO(o~vP`ogPdw+3YiUS&Q zwrh_iHkcjJDh&hmB`&wUxTK)1y?JzWXxomtg9r8=Ik^A)nG@HSF5O*SUcbBYVExXW z)tif#F6`U4cV=d~zrUxty0V}!FEi-3*)90G5=A6ftV@n9qQa$np$c+^8dn4wje57o zm0yqtSyH`S!=uA}Lj#>XU9}DM`9(#kY3UA^Q*SgvHzl^U5&s&w=V5pX``r{=Ryi4L zeirY2<8r8Ykrv;J8d?n z-RgEj&7vB1b7)ToRz37TW>e%QBuWtmNHY*o70k(OZmHX`edfaXW9w_zUp`;|@b=02 z+O6|vPwv=0-_g;6j-J=&B7_sGca$oj2a_LRJW9a{6#3^@9u27?fK|w*D#$rk16d+D z=PDifuWd*^!fL71ON8lNlWW3||h)OPlYpGJb$q>lOY-nkkU6?s}>gbUp z`)B8-+B#Zt^0RGDE5xJWXdtwf#<8v>2|;6XT5|J(qoado&!4=wc=q7oeS<^&g++yE zia=)~^lu0apmYpYOfj?`6jQW8#~Aet7ES4m2E9RtMR%0VX3oyeoERTmym;!_(|eyj zymlVgRD;Q+(Q4H+iPr}=EU4_DVF9e2_(B8j!r;`lY=l&_cTXIy zl?o*##>ffhzeOZcd`BKeJqgJ?ePWeSFj(Bg@~A{SNXQJQg9?SxghpcccO!l>@+$;M zC2?$uS7e1aRYFKN#jCl(OZr0bS=h>_gh^P1-n{7PhDId3{NVcvL*eK6*z#7ss7@9h zw-V75D{#XRc3^kaGFmirL@s3@=~5svw^)rJmvUIa#OHOUr+IRMX^nNI+vbL^Up@8d z-IL#beEqLqKm68%WHO3kt+HLO-sRE1p05An%JeTMhi~;)O#93Y z4qdr}DYVkLW-4gX1PrP)hJY#P=F2r`s_eQJn{L3U*>2Nb3_3qeHvD;X^rzi@t6gQ= z)6Eq?qA-}Er5Si+(b7VLvfM&dS|MCLOQ-PCQkPcl)GDkRsZk-atHd6S)T@!X@TUN# z6k;?eMT$lyqGckJQtYJ_KCRNG604;m7EFa=rbKcO&J*2K5*vOlsN@q2A&E*54lYY7 zp3jvE@7)V$Q=zEy1VP|=Toi8l`(R2)r9xId5;;W(RU#*pB9IDOx*$r9gt;a2RzBX5 z7a^2N2t!Y?_u`O$bDCFE4$;;0Bj6UWn=O`HfS6w4DnVjJ;<2|rP6 zYNKwx2u>9PObKs9e~Y~x`il|wF!B!bR=#K@l>oc3hf(;Xz>6U{f$W~pE)1>w%{Gft zqonm(s}t>#oDzkUkR=VRf|*&uUI)RoUq(EAunUu>;8rO} zQ#V;5@Eom;(MAJp>xj?`f}tq1;8bbgiX;fMXk4wUq%{S_g$q08mu_5LzO{UL>C&|u zS0QZb*7CKRODE2ptgf%MyPX<_qV+V9D3GNrT2?VIGgDG*IV2|wboZcP5U!*{da5sw z?h9m~DP3nW8m(qp$4GD~k{mm35)$LlIS!vd;e8i}*%Zm&X2A>V#S_pE7E$t6zRd!X zL)>sIh6>4hLToAuJ%u~hw^?fy?-G=wyjz3iPta z*1XN|F)pNx+JwD(ETQ75)aFfLgo+EEA_3`JSop?LsR%F?R;5QgeeodW$}h;-wPXJA z!#gjZ-@mzZ`TFHct2eJbdU*H6v-P*nA3nNsYvtk|_*>49vt zjZ8`wvMKUAH}M248Uqp%$lusZ1XRK}`uHtq)7{q5eB=7%r;qMFTwA$+=f?fp*Vk_? zKe~JC-kn=BGjoBgTu}<>rUas?@7Ro~@Ay`}7;GwnQ2m34Q5*F1ah^UxpZ=SKpKn~! z_cs+&|F_3CX#9V8{8wE=?a27x)a>}!?uzW~+(OQA!mg z`AD%fI3kpl2$_;aI3PboB$dKe9WqGODzuh|k~iGeN6}#ZO-@Nh@8X>NU_*0FQ*&)W zey+#s*6DQ$01bd)!LJ7zB#DH`jd-9WWK&W8yA8k;tE3_fDn+oc$CXv^5Xf#3;(u}E zFIxKT_iUGs-GUI(s^%W+(RS-*x=d(bMNnp1pA9@bN>_bCc~It%XGescBw4 z-j5S5gf^lKL!&jX-Dz{DdVK!$j9^xNc}Yb>ZDm7kVR^AHJxy!Wqp3SZ3i$$J+;|8z zuQJf5baZ@lcxtG%kWI=`^M9|$;{ z4qB^)^mtx}rU(roo8pCka`Ja!a4IPdOv&+f2HgjA0z#)$r^}I<=`SlUX=tqL>Td5F z=ouL5>*#Jn&wF-m(Cu;Quy-#MvCCbZ=fyA)cC8SY;u3Yp%N2*}V8sabB^k^H^oq^S z2{bj<&dpDqI(_`g)eG0IEiNxDUPE*8jivi*D-YLK@1k2*E*?E}V0LDzy}hlptTa76 z&1$vKAb?cimlnxHij-q%SR4dLnoi}yLWBxXm1VpGtj0^4TwaByWv!X3_y$&h1nDrB!wO+MQIEM z9eQt8R2KL2v~Ax$d-?L2r;qQxe764l$-TR`moA(;J~1}j)L563on--+BIJ5;>M|wi zYTuAeDMPpAVeBymn_{!jRZ&!mcjZ9AmRzT&oi3X<)#XifyPXcN+u6`iJvlM7WBbhX z)M#mG5!yjR78AVSWw=R)^+l?2@I1+YLT@6w-IAN_@9%BjwQFwi;)&b0udb~vFE3q~ zpPd}&?8~LC9RHX?AxG;>tId)TNG~cW>gw$r9v>VS z9js}n*BK2st6#06DfGfpYqc75UyUY<)8R_DY)=wN|4wXdP}x zQE5R>f9Kx4+b%7hxp3jsw(WB*?M>noE$=O%f6rVK3%TswU zMZD6ii4QFjFq=XzCq3Hq;66Td0y3MSkI(MFV9I6pcpW~UyC6Tax4ZG+-nq4#i=Tgd z_3z(4{_FDxH2x&x*LT1F`u_dfmn$nPJ9h3XEU$HVGwp7l-Q~7oFlB<+Ni%lyK`S2v z8B9RkJ$7xiQ(x*}@+@?=Nt0#J1oWzO27@WR zD%YqkvC@rBU5}ZbGi%QT>`yz2z8vWL{ov4pf$D>Ko;HI#kCOOlSq2QLA6xnI7)806 zs0VW)_&fGJM$v|;l325c&}S?_P+sl?c~p;-%O4#x|rR47I%oK1yd&johBcve;< z06UxFVt>l9DYg@BQ%Kel9}R`J2=G({q}mdbO-1via5feCN{BCQWa5itQ<18wkfkvM z>o_*WA6v|(u(O5@U%JuqiS6vMdFi@fib&KUG5I zAHb*-68VxM6`>!HC?v2*P%ErOJT{g7p#utU5E>NjaqCepR zSEEU-g@SU(Spp%eQbp3yL3^)urFzifOm8-!B?NlB3LFd$n^TOWAjdl~9;{?x`P+hA zqj)}fX%k<)7x6PZIbl^&T)Gtdm5?4O7J%9;jGPKrG{uE*)~3zhp?iW;+@UXqsLnt? zrlsU+r36iv5=kO@L&ot@=bKp`#p5aAjj-UUC^oev#HR4wAZ%(=guf5mg?Pj#prZ%% zdT9AnRG7ba*S2Sm?!A8b==$Z$OBXNRT)w(?=jQ!;x1K(@^X%c;y_K7{Z(MuvbhNJAy7u(porh~H5ANK2aQnu? z+c%!vTe-isIzKy?nHfw>xq2+pBe$Z?+!rTH}2sZd=m6#&o%kM@s=qiP zN-i@B3(S-XTIrh?aejKbp<7b zXk%!!7}3%lHl%Wy6!NFo0ki=EV`#m}=x{p&S%I?3vX1VK;jy9V*~x`%vkO~i#wLcl zdfICnYH|y5JgIK90*BqS9RDVG1XAn?1%(puC`>2NLfvY!dVQXp-0a%=n)c4Nfua8K zsqyKB+3ES&{-J^9*5;D35_Bd7Lm90J(Jg%Mhx+ zxe4w=Ua+#dysfQiaIkl3dVFkbsH?lZs-_|foyhDaEkh|)AtV)^XdRhxtz^Yia%H&Q z2Je+vt&|#)c;Mkf1zuiGS!r=&L+#K&@9u5e7B8K@ySDn^;o5@-YwPz`@2=jwvvU3V z(&e+KPHbD4>u7H&$jfy(o#5)yaCm~?Ba)`VN9po0Rv2YyG#b5LXLr~FfTW6A+nR<) z2WRJ|$0tWyJ6lUCN>Vd?dN!zE!9EIBIU@*G;tYvlnM)jrQt-D)Ubaf5p-CkWjb>i^c%tT9beO8vA z(dj6PQnAEM!PX;kJ&8(zuPquwg=dJ7FUsVC5y7U|Z6?0KH%_WGat*D}87QaAT2os# zF*Stdfjzqy`nuZP4m;Yy8jU)mkzvq0!#N_!b4qfhuwn}Ah6)AS?}@h6l~tu@Pak~$ z`oZfL>kseWym;Znwyjh3^;IUb0b<h&1fNl8LdJ!PynVi=~Mk_*?Bp^Tr@8gl~xpI>!`wAk~4FIN0X1z)1<8#@ejL+xv`#lBuSrenZ%U4f-c>Und zU*G==!ze78`tav(AO86K;g4TGyng-k?D@r>{_#L|k=>o{aQi?pWw)DcHsa&c^Iw0;4*emOE7vH~L7+Y#OOWC3b3LKCRNJmKo(Kj7+4JrBE`in@<7GK8srF zqm>>?Zc>WXGLA~&LF{`NOo3<$22PraY31W$&v~s>B4JZp2OmUBrI3uN@Z|H5fC`Wl zd`t;XJBJaGHx*)28}X=w2sRa7(nkz^@tk6c#a0o4ROF3M+NR*^2|Rs*n5hVrRBUAw zufX|A`1$`Sn?m=805n{>1oVu}@eb2aZIpk`H`ZYq5RQ++;ZKCFX%o+;c!m(ph=inw zWmEBy8mbVRia<{h(yVX~;9mq!{q4bJxkrX^MY5>`T-Ar`$g$i=qx5HH=!^_Rlrzv8 zBZBy;ghcLSk%HbDQV~fqBuPY2=ZE%Xk`!`X3~lqEdK;ZmjXH%!#poF*AAyaS!ECeO z4B;e_OoeWvB?PRa)HudgDF;XeWJyjj8oiOhg*7TPb*JDScGCaOy7_P{u$l%J1DZ2s zIHMaP2viWmg6{w$S1Hjs-Q{(ol_Wa9YtUN4W_Eg5`Ga zE1Szt#>nda0BY7w+G?>*dpjki4;SYxTyp zo6A>jUcb6@`Qr7Z#mA4$0egE@M0hsy+#!xV#+0;M&$z`GcGh)Oj>Env|gq-TXI1N>ZJF#C8 ze#(yjjvjwk5cMCK{=WGyoTq^nbqWY)z`Fp>SR^HDIo`Pj)QHa;=ipDGC<*N=t#(UZ zK~8gP!-0dlE}TDc>&E2=>nqQn-h239<-mcR_4UWNsm6eF3O zb?|*fA{7cY$4DwsL|$VF$tmEHR)R-~vf6D9m&5L~yWB3L$*2J}k(@OtOT`i#-p*>P zLRYAHGa$JkVk-irDQLPwvmBap()<}M?JYxNBYlGd-M!tN-5oWx)!EtE9*@TY)z1bQ z)q&_)i9tz02Aj=^eKE|-uXDZ*iR0ftm5XN}+z0e?kpRcBw<#Ps;iy*myZ*|%%&j;WdP z?%s~_@*tE25d?Z z%{RzU|TMZ=>Yy?z)3@#$4cwsRb_Dc%^ORx3gGVzmZ?SxwE2<5QzMc5mCW zZ`T-P=~ts8pw%-n92zEYaw!R$;y)!-l96nRmq^88Qv`Gf$iUT^y;_IAK$!weDu(P{+^zS$}*4F1IHO~t{PXXYg8nUg|h^zNSKt0&z)9i z877z=?CI`0a%k_f$9Mnu{OR9ce){44i#xZL_wLzMRaNQrdUbjoR9GsAMhN1Q2%F+Q zvXF{R2II1%qG1&Gdf;!%_`-UQO$mx7c`$`-yec(_s2M$l_OFEnIWtouYj>{w{L`!7 zetY-y$(`BhQL|A`B!4&*T&g4?_8Rt?C2R_p)1iZaUZ1R(%I>tbwKuM>UH|y*$@#O# z8tSTSRx>D1aQB21BVyt;2B&cto07BP{N%Yq&y-w-ODdAl>#MxHY;0_FKYDrY+TPOI zjE;;Ly{Dj#lLF5bL!;Gcid3qks6b9|>z?_;NB4GiwdUnzqiwzlRAFrK4g20izZnPj zNwA6)eZ}o{wY1jnKd^Ic?dJ1m>uBml$HZbWD4~Er$!g)qOB&a!p>?Cq2)@6bzV2(w zi?824xw>?5dUmp;yx3qds(@KiXiC%>^ynj@NklY7*c5}cQU;UJ2!ZF&^@E-Zli5&M zlzZgRo_8-Fefj+H&o4jz`orr>7f&}d)LCtIHKiq00U9EdB7x_mnUs|HfQe7a3#Hg0 zO9}flj7^DRu&I=!jo1|1z9&i$jwF!)I)yVRL8N(X)+C6d;YWP<7uo#es2Y0V&kO!s zG^Y|pc=}?psU$4w05*jtZ7rkG8MI1`f^_WiNQxXH5`@mNDOUB$vne?{MRPN}ngdfp zHl=0R6r-bctXv8{V!4#jW;fa#W{1<}_Bed$&UC-4s32=(pyT!Pwcmev^RM4N{Q2vL zKY#h~=WieX_4`No^tTV_rSi*9?~k26RomR@@#i^GGaN3D&FQi_oCHjfNN}zGKLJblxI_BE@{d|$vu=j z6%2jq3R*d2rq7k9|FEy~-&g0~%(NUY@(ntedOK6<&=%O}Y!ekQs5A6R5KS?vAfqZY zQsCzEng&doT^99vP4?%RwtpWO{$o%7rSh}^J5@wUvS?YRR_dqlfL1<5sY%mdV`{D1 z5~C(l3t-BwkvM6&O(Qd-+iHoAQ8_7vQ7NY7B1$HrgltMC(#b?#ts;$4+0-%$6jRA^ z!2p#Mz$mtoPZ}#)icqQ0;Mr6%3}8@67(l^`nPpSa>M0?cO5sKrn+l6Sk2Lp%2c*aI zZ@uJ1c5rMeE`+Msm?`$_g3`T^uu7QzMA#I*!KR=m{GDL)uXCsP|COx|-K7+95?V0R zv|1_^K?XC|uC*bO3gww^fq@BCwDV4gfW8th6aB***Z?H1rN9QI6O+p48PT5tVb1tP-OXcDeDMY3uiQ>7mz(g`3i-8mYn@Yhh z8(h!^rG99>q8S>kCD4w^jFvABJFqEq4#gRg=xm67f3k>(tk_itETzz1Nv)77$h8|W z_Ty7P#%Pi_p@MsYO@A;AVi^^hz|kExSxlsZ4=qlhNn9*aXp}_fgU-chf<^m5ieVfc zr_pN0`fZiTYO>g^c9+B9aXH*hi`AT(?kg%QsjRK4uB#px?$623&Cbsa7UZO7`dvP+ z&Eul=jEd6eje3j2s@6gRj1o)wEe?y*<3yVynNkK`NQKN~x1#lf3KtIQjXHGy(SuD$ zh~oroTX^-Iz#__nju-$WLg2KamNPREWSPtU>}Ed1Nc$^fP!NyLjxdC3e@-E3%(M$SPkT#vN>#dg}L3mod*u? zy|udhsVt!`po*ldP@7l3v`}F)&cV9ss>!TJduwP5*o>42N}8> z>}@`AS8zF-)k?|mAbL3<7$6Y=?J>kE=45B~bhREnuxt6sxrb}FUOj#A@y)Xjub#Yp z@$l(`yDQh0E}pt@<^1B63l~nEIJ#}?Y;{$o-ELQFG~|&$QJR{~PSM~1b^sTY3Z3XF zJP5l`a#=5tiXb@V({Sy|HskzQIY#bvPM609I(mXBAb=w!FuUt6w>D}|sKY#f6_WAS2 z_wKA-+p%-Ly0+5caFDEZ6^(ar4Ah@#K&&D#zi3E`I`;8uG$xBBCog+&py%xAW6vJn z`}L>yfBgRA4l)^y!P^!87t3$!R z0LZ2iYv=enEjg?1lNe08lCpx+XAZ60TD*Ss;+2c%AKbsaXZyDK>4~n6=KTC@v&qN@ zkE=nE1dI`<&;W|WIxmpu;I>c+a4DsX%y{TeXmuK=)0UBurq?s@!UN$G@#V=l#TPtS zND|}>eIbh?v6?E;&R>lFmD}xTZEZMr?!@Bdvqh!F=m3I<3VuvUOng$M0!?%19-xCi zy)b_2{GmMuww6{Fp|zzFmyi-%k2`mWDH#E?_x_b5H%Lmu4 zUFhylTAmD>(C9PX@&Ppg-aA*tRiN}2;ewg-t)U=Qbm+*x0|OezR1j1?*sMxumi=RBAK00s0ZoY)8f zPN+~Xibq9KChm(-WnPhxic6OYHF*gjRpb|=e^toPCje7y`g&40mBOaN(5GRK3m&OT zqtF>3>jO=4BmrI|$bN@ICrM^)eb5q>B4b-ExFJwXu>n&!wF%FYD%@ZWU`k8E&viKY z+{hR~E(HNoR;$V3u((_{m&fMuIlXC)U`~2xN5kbyCx6A!QeS>~_xmqzfB*H}m(TCN zV8zs*zkm4s^M~gzo=neg3+9%(eOVAN<@Q({PK(WMwqnJU#e@T)ZI%(-e10?-RVJe< zGSgKKrrD|QvFW$!)T<@wKhL)O`|!|j`vz_`7W9}^C0c0^gi^9hTI$z`(Z^h!yxgR& zw`v=0OsP?w$)GzRacCqit=tS&KCxXTL3hcik{IMEL@uSlg9B5^v@F@G6r(%f(8y>- zih_uyBrK95_B|Qy<|9Gq8_1=wcaH^AcqAtX2UpC;>83&>p8FUw@rjbcJ$*6h6BbP+ zg-BF1n_|PyF_?-=PUMVxtaK`@Uys=LxSqZ^{!JS4=q1Dn6jS^c!y5X&!lpKK^ZjoI zW@TbYGI~{OC?!Rypg=GQv#AY*Qem-6LN>+WsVy<(OdEkIUbqqsm!gu=H*yF@Tlr!H zOl>q`sjWDzS5zvyFlZ}I*fSXW5QW$jqo>_oC$YVt8C4Fjg>1W$!12v>RX`}2BnbzU z;rUsdjLz3+Nr^T=I9(PZs?ZdQ&R!a=7M#y+7r-KD)|L{Sh2|*quh0ojj#JPf2wfos z2M0;Gh4MSJ1cC%|H0j}FCppQRN`YclDHdPpqzbf1kU`Rg$v{>wn2$lPAHKu@(ZOg^ zwb(6Mz)EVZfl*_16S|Efq-dSVV76P$HjB+^PtEXUkd!{K&0y>9dmA-77Sq;!w+Y)O zCPI$_eFME0ws1g+?b_p+m=H+`BvJz2wduQXq10y9!G}NH#ATrqHWil`Cqk!kxrAJx zOhQK&+dPvcB6ORSNTO3=b!F+vqX&L?|Ki>2$7^?P-no5aeSP)GvwQc}Zr@zKc4y`0 z!}UAQ9XIRyhRj73BaL~_dsACO2%-yB$C!?jFF zA$b!1D8@0oXhQ_ohjFSf+6sYk2YetBHhUajP3NgdIATh|ejLidK?n^=o(9vT`!pI$CDtrVbz7fAR9!rRBxrClBx3wQY1_xT&=v zJ2%ticIr(=Qk4jOYEb)5p`|R^YoqxyEfB~lDay z%LGZBlmx7fl$JshvM_lE}fF&Uz~Gr&2y+3O#-3ae>t<=r6A< zZSQIun;e~(9v>bX?&|HTt*_3?&UCtMMw6a~i%LqNO^+oHm(5`d?xm4sJKde;C zbvkVzklxf(H#<9d_|V=POBdE}UwirZ?#DNeKfQVS)ze|UjDzJLAr>BGCn4;>!t z?XRw?%FWI3cs*DsrREZ!RP1$jK|TqEtM@=yqCuN7*qTug-lg}Xy7Ka~+dEq)rpD&x zr>18n28a7At15!!Pxj?~!kZc~Mt15K(3&?JamiVgr*2{lwCd6-K z{MOA&A3r|-`RCWmS1*nY4Of;`dR!j6&1N!zg%6$=PQe8%M6D#6D~R8LQWbP66r0V) z!os}jsP7lsIe(jsQBw>Hf6V zw&vNn$!*)`+B;g(Gkoay17jrIT&0o$mQkQ(VP>{}WMW|Fo~?bu-FZbpx6iIOX`y_F zIGtIvE9Dsik?*3{LuqN@-2B9qrL#A0T;8{TM_+$eL1B)?YNWLo#IXTEDvcH%1zH|! z^>jwS*WTWE>g2)I)uqM7GrM+S1G&&V*_tk8YN;JP)2VdJE9d=(nQu_*>VqPHS2 zD~S3*YvB62%2Ou}JbJkD;}0*t{PzCE)Ad6K_O!RRWd?)j+(YYhYMO>On1)1DV}%|E zrlc555h-$H`yPK9!epM{DM6TdsCrK*lu8!#)+LMBj{@Uf6p{*KQz7&e3PZ-J<^uE- zFXT>1;oK=PoI52(5~>)3M^faU;H&Lm%@c`2kcxn*aM4r(ZtG(MrqGc=a~G7eXu!vp z!iH`ok?7`7(v$?B(`9VIcNCbCk~bi)Sq;5}s1TTfSBH*4+aiNOhh|9VWe*eespML!G`tIG;$(i|_ z{0et!zzLOnZmSdIQn-@OqBoh)$sMy$HvAmG6cZjWMOyjT@N+zWhB_2j9>ouGcEjx_ zQl(&ov8k_0rzk9)0z9RZVmu`WHl>ysHFC2?ZUr_aCv3_`%L9xepH}rS%8OO$A9gkW zd3o&p*7kjw&R&PE&cReTnPRIp&q8M!RDK=AO!*mQj$U1Ap&Fb_k3%Oj;VCBmqjA!^lgG>Us;^Xw_DlG&y=jx>o9;r7l`# z*GSDuiB&1Ft0Ydf%%n(R6l^7*h76eq4N5N3D@0xzOo&FMSS3qlt$dPXGC(oK<0)|r zD<50K$FeClU5ezKhhnCHO~qqFUzAEJ7Mlv;Db}_3l@XVev?U5m#U)3)-4dhSe4JJ) zoKOiyJRY%wq=c;LKjKb*4YK~y&`0hM_VIxj675!q7*d+T%D18wQ(VG1x8>)9p~5_O z;kRSZp$G=GkE`}c35JZbA=WRDd?X|k|lD9 zhE|(wMui$JFr+G+-z$R^KUn-^P%0bnA`UCGgHbPVGXVp-Y}phBroM}4=!?vo z3TIP-hCa-uxEryPrbsv6Kf+7;zKLQ}0q-erH=%VDLmrg_V&$_9pddwV<3hO4ckxv`}_zaZCPx1%Z6g#M;kr)AK(Q3(u6Dafzj z`q$VSxDt-wDahGI3qnevWz^`Odp!1%lKhsI`k~?8iOG@a*@>OtoZ7i-@Aif5vtyGZ zb&a*T`8jAqZL*m(S`BOr(Jr2%(2Ch;fe0yIhA$(KksiqK!SJUA10FQBdR%&oNu{Nv zIA@*@4Z~NErD)@dc3WtJ=1KGA6%`a$l$KXlRMu8i)>T*6SC>|m<`m|7)4XU-CWc}V zv0yckf~1=%7G?yX0}g_u(92RT73PP?@u!@LPe$te6r?zk=m4>CGR)Jbz<7!`^x>@vI<=uE zH{G9JQdZK`($wA8H8|2gGCtHh(2bt`lJerrpx^1TW5^~aTuaU-hJB4f$RjhRxB;>uT)p8{tMJ~vX5)6uSg;4N1r`>L6PEN3@x}u}AbqGD! zu_5%DZ*6NTuPDt5W?HQlt(GRa^pHCwi2GIwNECltCDc%p9PRD|4oY`_#>szoFaXeLppWi+D+WTkg@H!mzq96hw> z;+f-XD_3t_UtGL+a$;CBC6j8qLP6V4$(7uCu4T zwY|Byt*NTE61|Jj(ZhaE5D20Bhvo{a&4P}6X+=>(OHF%Mb7ON|Mj%b21!X>Nh?dBB zogo_m2er{kwcKddWo7vX`g@KY+kbKK)X@|BXXhr1OA1|X2gA^C^x!4OR!IUlRm=58 zU4}ocrL|$#u7#zm=dN5nd;Hje{{F6_;zF;_3#EOKb51(fFpt9Y3Ae8SiUKSJMQl2q z0frV6EQixtP>?e`*nMU3)Teh(fBEtCs}~P0FP@zk8!jp?a=6{J-k_psHF~Gel#I5&qu3OVMu+5cxdgn`(1L`{xMC4YrDCxuDa)p$ zk!(uJiKd8ZkuYHnOwm~N#%MSnADetmz?9Wuvf0c;F@*!BT$!1^+M3e6yB6-;y87we zv)_MxkH&AmzWePLxIysLm(L&GzI%3c>GI6%d|`2w%bN)SQ!W=&^4V-A3!8info4Vn zY{vv(iUKyJ7UTgcc`&8o9K_1d$weA5h_g=_&ZfZGry!!K|By|gHYr+fg#*HMTjKYNxi$t}V1^b4;2{P)xDie1#^e#-{DC zGh;UGUaR(bOYZ0GZC?%yyqat}Q<~Al$n&+bAXZETXh}dT4Kng#qq^EcH(Ka=GhG0` zN}ftfJ+#cNm0MI|t6JhvOPy+|RVmQ{m=f_|io$G)l0gKzRV7K&Dr_o=R-U5dW2QJT zC16uu5l#ISo8s^kN1|d9s#vW z*;M$q{sK4s9X7RrwrZ2$RTl10eWN7lVS#)M|ibO1x%ha@n($OG!62nyq%(z6PER{qr z$`mrCMkxlvju=hyCac+KF-a9tFjng*xk@IIiqMeY-d++%iB9?^t5HQMNrWJ-!$6aM zid-d!X%pm9T67-Am)_*ixXMtZ6&HS3t-v9`Xbq{rfmBKpWKTKJon+9QZ#5arCY?c_ zp6T}oGu^3PgT-vN+x*#?4v$NVekZLqI{;8YufD7IhQ$rO~8N~^r_sgaz@dPr;7`NAU?(1p_{4blfrL2xX#)NV znEQZDq1PT3sEE-{A5+S@+RD=>4t;v}{Kro(U%q&>dh6PiOXn}1KX>}X>BIXEA3J#X z>ZOa1?%nzD=IKu#-mI6JIAwLzw z6OOkfK5+|%Y#~J=aUT;fwRtlun&K5xESvi7AK`e4bM}1~n@#v5sbxSI@;*csYvHTu%M z1%)|v^_6{n9a|TsP8>gY;o`~TCk}4kxiB^{($dygSd{PadC(+}y|n1hNM%X|nlSYy zgT-lcc-`)_RG&XRkeiiLkQ2-crUlZR9w)lR&E-hX z3Y3(WwRd$4jt))EPR?$fotd8+9O-LqYbdWM&dT30&57m`Pj`k`h_&3F`4yVud}!)x4Wz5 zz=3V2jvu^r8;!@$_&DA*GTusvy+J#%JW^bw|J148Lv2I|XcXD!kW_D_Pa-_DQ zCKIyUt+bZHIYM$CQ$&=|MZhH?o8o>(9?7Nzxl9Crpf?CQ_$HG+HPuyE5S*DBK6~cy z{k7#c&+or^_Ta^nwOcnX?btTc+T4(n8?;)?G{m`63T%6W$IEWj2%DlbxM2-Gq6bN9 zEH<;p>++snd-(94!GW%vV3xz-Fc=IpO=~o2K@e696CaKQ z4;5%`#HPM3qY4vE5jF+VHMv@?plB7Nql{*~(`9e(Y+k-`>B*C|YnRXO*}iple7LKv zsj9r#m+D3j4xU*EFTyQ>Kp@pzB)bX{-!*Ej7KH9DmjlgX=*hi!?%1mr>py&W@&5JG z+c&R_jSiq4H}ESAoVY`%44bb)cuFoTT(!%o_jb7E2)#Wp@6X(yJymM#y_U)yK z$82+_1eBYJL>A|tX4bC=)lKE)1-q>sZkSA8SXTc$+%iusf+_t;r2Z?!;tlu zi+B?~$6LbKl!*25aY!m9X3lw(cTez@uaKx{Disq_aiA$2PyKB+Mer0j5FtJ{1%s)i zh^oG1QGx(Tv7LR`^noU74WkF4Al{!Qi#Q|&5-d31g)*jiFh#;Mxw=*EVgyz-^FiWj z9J>cq3Fw(*u$50o5g#85rYr!a>~;&dQasSdmzL%VW~bHFmhRuP_4V@ypMQMw<(K!r z{qpX&U*CQH6+Zs<>-*n6fB5~k4{zT-yLkEH(CB1tLAlGD>GG!ATpo+lX|h=XOqm4X z=LYmA83Lv-W2exnM#F+BwhUB&vdPpciwUNb!U0H1LWY97LHq@3oIr(*eiA~fLP6+U z>8eQ5- zr?$kd&9~6m234j`8DIcR^I+;iv>gEf@OyQ)dudpece9p5eoEHMMBJAydj} zJ&p4OWDMGlnT=>xB!Vbn=o3kjMN$#^0W>9|)uv1V8#m7GM`#rgCv>k!&K24rqFEGt zA2_{A4jCORo5I({q$HOTtyHngUW)!YcH~LXJZyE?EOx6_uS@f%XXOU{Spg?F`|QA` z+)lI`Nr_ zfe){r{_yeT^Jn)Va_Z{h(v`&v=Pn#Oc=*)Oqc@kXym-9!>D{xRKfSqgb7g#V%I6En z6lz#)V17t?KSN-OJp$2S>O1yh-1l(_oB8|6Yt;zi;~3W#{#W6LjGu7;Q{MrY+WcLJ zN`3#&|B1z>{s|*Cn-Y5ZxY|B8V=6pv>c74Xfhhrrie^*aMzg7qHSh1b^ZuTLZzDDZ z3FlxPg`()hq$IR}PV=WVwKU9coj!N&`0H1XU%a@#eaBo*UQjBR0GlG|OoZr!j~Hx9 z2&P04NQx6p5gsLq3bPWhDY$RRiHT@gE)}C!pvh|X_`GPKc|&gmp(ffZVUwCDRLzsZ z(I*1G!khRTM@+~Qnk zstaavr3|+U;$2KqqBuDj^rW}|5loi~DWvdOjGhc%QDtdsSNq`j@Yvks;KWE%drMYs zw#{Xybu`prurLbeEaCKTEI)&Ubg+19HAb5`Ei1jGs;srAV{~R>=iXg=5A9vpxiB<7 z)Y#IHlb3C^n$Z?tE|U^~3CB4lSt1rmC2Xt~$-oB+N~w$%gFoo6s;}xD>P5d~-;sR> zk00E+d;8${NJCq5K}n(A?Lg~unOuhLhZt?~o>LGQu!o%$hJn2l$4Mzzvjzy06ht&7 z#w?NFo`97S*c6GNSIQ__?e;oL%Zod@+9qelckbJ{bI-1!(V_arx~%Lhv(=1Fd{|5v zice?5)wz^)S)^`?15=!Kh+|VS{-2P`E9h6DCp|qQwXLmTetzQAiGw$;U%Y?+=IV{5 zhwHarK7aJ?_4A*8c=yA{H;*2yU%j+=VDG-s;o-u9BD5*iP!vvQQm`Hm>>(mMc7iF? zJeyLH?_dz5QG-V{D^Oiq-9Om3uytdi-rV5wxqZW46@j4tOn^Pp0$)psebUCfnmBsV3BTJV~{`ld=A74Iw{^`xjM{A4c zP7M$B7Zn#6afSd;5hdXftS*JSe=43$skJ0*3evFkI&EEj<-*n}G}_u4(H4+qD4dn8 z(ZfYC16(Y_;YzIJh>u}c#eN7O9;J}+LCVn@xoG)ZxM!2Sts;TvfbW3Qsx=B1Napfu zs>;esiU<4qZ{Ap1zIJJ7pwI1aq1Owb4xHGGH_;lxrtqc}z$1PNpv)0{3oYs#4trgF z&DL$ROG_8uy?OTUKY#lC^V^qC*RNbWGdnd_P>_SR;Y!>$sOFQYxPavlo8s{l$$`ga zZS?Y>XsWEdY;JxA{r=9b)>NMxrW#V~NmJlB*3z^d?d=(x(@|7f+&9#dos(_0nv^&u zLW&zsvHcki2+T0p>;@zUV%+6uWk~Co%$(rN{OsEL>Z=zIL7r5UZ?l=f^@+3Y)i~vz zOtZu;ho1M;^t7(-&f9lxzIprn=FO#<*@=Rpe45eXicbpa_k?VU_3`P*U_wI=iYdTU zw3bo((^F@s$L{|ByuF8a6i3?jeZKeI_3mRpabov`o}THRoM$vjqnvX_SpwyN5J4hm z48|DS7~2>yV3GlYO)}s}uy?)x)>n5`bx%(aw)cC^$EhQFf<`?Zs;ho|UDti}^Iu;+ z|M$Ot`u^#?!-w~_wzaywel!>YoB>pdH(59%boC~j$VVVJ4V8j~b0%Y`6xf;ZJrvBQ z7<{!#Ht~^4+)64%^igSSin5&~5~ToB#H^R@yju%QrM)3ruH==`@t5NMd*d7M&38P8 zmrNp(o+^n=B`2b5@=+ga6RjfL0XM3(G+sagQz{b1s{~VeM%lECRB*%~-BUCH zk$i3?qA9!8?i8F(JAf%KfT=)$224d`fwFkPz{d8I$M?PX@iF-LUOs>Q%hT7tJbV4} z`77LBL;K;?uRp&3(FeT)W5wn5!Gf}2L7_K zvneH*A|?5fz2wqek|YzK&S=z0U`mUc0plr|P#GmQWinz^1#C)3z*K@wnFyQG3lM~^ zb8vbkn+jRjsFf|U87i%&ej9hbyW;!(gRhT`J(y|R6||28Y~2BCtKZt-wN^OHanV$Q z6;tJ+x!TEf2ke{t_MKkg!$SAdvFhJXj{WD@)a}vMy+yuuPFp1y;x?w(qARj!OKrfZ zT3uWZuqnR7&DV-t$fS$#OiVCD1=eX)d(C>ZK3GkOPXVR8KYHfRYo+qCNZJ+Z8MHc;$;|Q? z8VlkdvnhpAC^hA2ZNbudxfWg;n_8Dmvw)<`8A&OToy?sS&m`1MDVnPk?Ne5!_ou%n zO`w$|wfYlmN)mD?Hbr{ClyVmky@%54jpYIP7*eUw$TknWcnlA9?)ZEy&UCWCO&KF^ z5j`$nB#5rjB(f6qt7xEwX8mZF!R*P1rZ%YW&ZCniEPT>H?lBAuplV*gjqi`MB$X6> zh!%&d9qI|3 z!UjnI2D*jSr+Tc#GFpskJ(SRL`@983F*MUeU(khm{z%Xl^a~ErBJjaTP;}b$Mn$3@)dK*KY z^_V_o;{y-%Fgau-pbVIzDd<@^p*?#&IUsT6&>WoHrR4;xJLLC<19p$g3>srl#I?0H zy>sN?lW*@l|L*?7`?tUT>e}sFSMPjv{pO8pS1w(+cID#zyVsvT`TFPYAN=zDP<*dt7Wux7lo1dMPvp&J!XnjK< zcv;zUY}ea34gPJikZ$E8R4T>OmjF`}iPI&I9R4b3gg??1eM-=V!*wk`Jd z_e5h6hfB1e-VCOVKrjr(L_jeVu>wd!lZzOJMx#&*A$CJ+(MzZ=1WBs9Bwji&FmUkT z{!c#p`0BMUE`4$S;GqK(lbhSxTjOQ%V8~D7sY!w~XTtqC&L4)Ero|r&Rn^sW4RmiD z>u>39EiNmzIt1J+stMo2APy^$^ja1Tzj5r632VSSK3}}1s%x-s)9lpT@|L-6TZSh_ z8{1n-D&lUxm$O+}JPl-U(JtZuA_@c+&kz}$#qAFT%Bm{bx;sWE#uv6P?K-#@wdK`q z6SI?@z1<~cr5>LL%~i=}(Q2g-8wS_qtL>366 zpu!<#_&H{nQlh(Td1Dg(EYK$;gi=rv6e~%1o(l$jU7f9`P8_^-_4B9S-udPEqgOvY z{qoAilP8W&O^jDnmbqLG2AfzRO`0_9W}y}Ru&xPwZ44F0p~DXKX(eUFqoe(Y53GFg z*+(yb{O;ecf4cGIrMcNDQ4}zU!M}wKpHvP+O5)K(DWyP&A(9?hC6&|+Oph^E7+i4LgaV1|4! zso~@V3ohElVc#M?ZPBNr;hYIgY~5Z@cX!v_uWtPC{PCj)UtjwClS2pg_HXQq6~=6W z4R0$wj;yCV3cGYk0Yjt27+J}?$B;dUwv5dt#A30*p@BX7_Y92;RoB&c{XTM}@ira@ zE18TI2&i>>J#F1By#rm1E%kwL5UoEhNCz(LL}>sMBg0!<;u)Qm29wq54TXotM^1lq z`pS(fCr_X3>F@Ogd`9%`An=MshdK{++01w&0{%sx=?@0l+S_)n?6`R8{0~1qJ@(GA zp5ESYBm$OXs10ZV5nW=wPuUd7JSPh__y<%9H5@g@`TU;t_NI4^?fd?_Z(siO^yQCF zzy12w-aV^jW#xk1K?BdxL5yZfB=a1@QpSj@@9A-{Ax=6{T$u2E6Mce8k-Bn{+ggq9 zCKDA)#0!?iDJs*@cCSUpf3~&L}S5NVX&dTeD~_o&FdF`eev`+V&cPc zDNszk0zCEW>+fH@cz*BOuMZwSUS8c?P+T1_) zRrz?R?TF592=KIlZi-m>Xe9@^ZUW&^v?tTc%nkgxq#2UrQZk;B*%T#IMrZ^~p@E*+ zpv7#8R_LQy=tjNGs3%ENc9YI&*1I^yV_|(3HpsDIo-ME%O032v-n8tqJ=)Uo>#?!t zyEcB-9^d5V`+~NPpsmGct#k9`4lXX5;t(@ss&iS|1LEeOW1HRbQIYrYV9kFH4*%!m z<|hlC`%1h$Hn!5r#BFQ|ua66CnZQ<9*=8r#+dZb}}N)YK~JU`{phWv7v-HINk5P-Ul6skPZuR?@af`3g3bo0U$e{s2ZP zJ~jcPGUcTc+_WaJ%1gpopqNtSvaAlBm_)cJ*sZ7^poRHzvPes@^2tmlHE(JSyIf8N zq?1v$1cd4hY$_`gn_5dErBq2Jv!->)57WJSZ+Msy#L4!tl(;Qugh7#jsT4MqN7N%& zy8fXrTtWTBqg(UZvHbYcZNfIJ|DPUSl+qk)eqbY!1}9`P?{81YPn_FAbeM z>Z|p5dSZZKl@12*jE0o20(gZ>QG>6;4s|`@*Pn(yg&cRy->y9Le5e-1g%_3T<4QSm^ zPol|#%yV@aucDJhWZuc)Uoy>m@A_1542M%w17(F2E9_a0bT zT3%dQT9};L)YQ^YToUsIJR*oB&2S5tp(AZAjSbg=UrZ;1sf1!m^M=ZLgi2+owI_?L z;0>suevdJ+7SZYsczhwh7l+Z=93tu~3}#$<8+B_$|0x?1%8J4TL8lwi|45QHi6_ECzQj}%NQGWY zbTZ_Ys{z-zmojfnR#ET-{N>eE10zFw4(vVs;pt;1j_zFDF+DduFg(!K(OMEO35J6% zmrFo{VBP`%0rFB{eusV+jaOsEg=N(hHI23Ptqt+2icl=-3HwF2lLMO!tI+Py(tdErzd;DI(E^=1h2&qIk z%Gf9;$-q1jGJotgPry@98mnrk=^p6WG_!eOd2xB?^468Dlk-#POSN>gRa93+V+BsP z8%_G4`XPip>9IBmHV&3ZsdZWv>iN;2+U^p=(NJY=RnNf2sfD?vojbPg-HqDZ^45`w ziT0kJs=C@}VS(G{vRExx1%c+yTCL>7l;>_*nhAy*c}AZQBqV$s3QYo}sA0Jj`ZTl$ zEu0C>HA3NFX}qMnuWR$<`26C`!qVK#+*DtGZ(T!OVR50y=dnV5KF(K{BT7h(Cz`dc zWtaq;qSPXpQKWDTf@sk69}J8EZ)I&o|6uRJ;_Q(l`#$^R%$=KG+`f7F?(HwXynNy6 z#S6D@T)lVq`n$)EFV4;n^lj|wY^$!R@CW^ZC~y`yR>)m*A|Eo5cpY1u3dQkD)0zTI$$B}1J_CRvzC&5+fV&Gk zh=O5~!!6dD zrw?nK&@zusYBVyma5kIG>2gI2BAdoXCnm=F`noDA;*gM!23ms6%yHm2GsuEBDU{wU ztE3WJ1K+X)rL5f{wsf>i&rUCGTN)Z2s%vPlJ6wX@fu`{$^nqsZL~%CWLX=1j(cy7~ z3q#(Z$7;74NcI$Ayr}=g)%Q?8hQSmjR1jFIx4T_sRTV>{BL|KgJonkhyZ7%J9v_KU zmN~t&TOfh??t>5B+r4{rZf>Tcvcl{4!I!mg0H%l# z#Y#i+F{C1%J{wPy&msC8{j}hivOvJs(cZj!b@}qekDovJ`o&LAzWDr;J-b#11_z2t zN}O(}#K%#s6p1Fo(NaU8v?~|#lbn52E`>G@x`>eK+gQJ? zmNt>Zrli_@No*>ip2CF6pi|yQNYv)TMmbPiVm3v<6jaF*tqzBPE*5T3Oc5~U1s`8w zsH8a3)?9n^!0Me_U;OgJqu*XU`}M`sS1+EudI=4Dd@rB>_WGwEe|mP|%B8Ir>R5Dh#Owk(q@nw22=P+5K|FPABmr0wVXj~G3ap86g1wX!@4O_q)%@*W6_ip zHWkF8shHIew-~y3)6$LwbN4R;NpU*Trk!; zxHhkCFyz?cvYiOnZ?~7d-roQFvB_WejC|Tsw8>?v<#m9hY^X710#j~ds|7;`j+yFl zTbmqQDbEz}`a;1Jo#hA7RZ~j8z4@~N*sI!4RP~HLFg*cs19)Yh=p+*G$y^8 zWpKlWz9c*)Q7M^INxG?AMa$EyO{FwMC6#RA%Ltd!@}p9OQgk6dg-zvUORhbFo&Ypu zAXEt?wPwpz{LD*MI#HCAF+xgyDJNmR`vaBKpOjI7TnBp<@#$|c>aCD?Ah_J3AoA$! z&QGh#N2NZ=Y$~}ac}`Yxz*I&V)do2oJ=n$oj&`-698q)%zGs1)3^mbouoH>EK2 z<;X?)l$=W1fRa!uWgmgMRf~l{*wcsR1&onVLosn3x+v?>Y>eleUN>6S!mW9@O^l{y z42YCKMJ!*)h{p}>O+8jg!L4K{2u>aDP-su!ZGw%sV2BY9{UmpDFci`dPKB1uRZ5|tFWuMMg#EUeYxUx#`w77i!6 zID(NNS|2pkLftaBHVmv9kVsyhDvtzZL%0@;brE_kq^VQ+x|vin%*oBx0doT%Uv^%$ zMz11Q_B`U^}_^3WuGc+Ky+66Qz4irR!v8XQ+LbGEdHfC0o6)(a#7cO4CaOulSUtGI%<@y&_Ze6~5`^#&$Z(RHO_VsUW-~RZ6k4A<@ zoi2Ai1fl0ak-j|GYh;x+WGnELl1c$~!}2F0oyu94tIE#P;4C|KT4WXS&(qnIGGI!9q~1!d)AxreskLhMt>NkWb8+bSoqxkk`75bx>Mfdu zJ~G-rJu}un*j-y!9gmj=LqT+cqtlsCCY6?$;DASg-jbow;;4}c3vOz;rKC=+6*EON zQHtbqT4)b-M`$F5IzZ87NBxh>?{avZs24&V1)77%xf~>@U!zNokW$n+O3VoKG%g9v z9RlHCS$TO|TkFRD-pg_62`n}!{QyKLUR+aOUEkQyKQu5nHaa{$J~cPHZDq&O_N{{>L-mdIMa4zFfZyeY z*b@k9#V)Qu{-D30umH7SB!pJAu%xK4w5Xt@Fj^D?ffMQ>jRvSX2_f(}L<>Vg zAX1DT&DU&#;PH85#j)D@>h6tQ{lk45hkJVmy1O=Z*0Vr*v1?Be#t`K@!4vlBz310CIMl{J--f{4fK z5k$dk#<@%MpN{$gby`Lbz6lN}kiD>|pr)>-tG8!#^QM`F`Ni$q=9iZy=Vu2ujdg4U zBvnvc7TssWqHjAO&F< zjHDb+p}08O*jUrk)3Isu=$WJ#H%m?`w4C<=jqADz^#txaR& z!}D8aw=OR%ZJnQ(8td)rEGv%(!y$*$fzEdm%~m4bIBLyPuqlI*O(koAlt{{8NVxx~ zWsm+A_J>-n7Qf$9Sy?(f*t2_e+eaUqym9sXw|BpM@b$IN&YeDVVE5$avBvs_NTks2 za+xg_@|%e=ezIwi=7>R*0c$d%VN9$j*4o~@X<~He_N|8x?n9q^=Jbj8Pai+=&Vg-P zXWQDEOG-;z9ydDC%$VRQgUupW@@LSN zKvQX--y4q?w=~x`)K#PTE^mR?Z5Vp{eV%~d>vY*^p;80M{vskVMF~YkdKf{Aq<_P# z+vN7RE33*2lg}ynO)!PI#bN2Ah0ALw(IN7by!bnGF%ksAQk3W9zv-4-)d+(jOx#{|b`hr-2U>CtxNWc_NwNkjD z5hohf(6A{f1s#&lK{_Sc0zqGWedUhjxsTpIe(&~`AHKVH|L*k@$B&GUj#O3G_(NgA zZil!t9t;dvD`m#UDoUm3z+0cF1DlXbX=#L1VgYMDB`~E{h@(^q`<_NwdM~vApE_MA z^=H{sia{@hQ~fnIB|lu-)0dh$m9c=JTAAXG*_1|;k2+p-UABp6uW@K|skJHvzDr_L zG~YvFQ~H#oDO@sDE>=R5@uZk3iv@!zE2+wd!Ia&G!4#GN$Y81{R9RKh+tYgV(C+(p zzWn+7hmbCX+p8BuGz9@uuV4P~{QIY$UbwKheWkIjH(Fd30x(sG&J%P(VlahEw~&A- zksf|HV~Ql7b66XR8x#%1qA5}+0V^;iHYG`?SR$R0)Ke0hG9=iPZY?%t#B7Qf`Y4++ z5Ybc$o6=EFUxH0BN<&{E&sJF2LBaTGQ}orbk(UPsuaDNO#vDUITW8SP?B(m+T$O{X zbePL*#%j^j?6&mzg~@=hrr`N>$M1(H{&Q^l{z&7lsJ+dmudsq#svHzkVCAc_ zu}yYUkDKpv+gcr5wO}mfnPR~Zv9MmF)@{;yImXYk7)+^nhSuhzawz~)Y7Sfc&^yBx zCTP|REOzrHz*G{O(ks}MUb6<9(j>7dZ5p9c=O;p?D4SCKA)87!@yYtAblp@Eo5~=d zQn0BvKq{F{WoQ^W{Q;Z$BZ~D`TfQnslhBu{8OS4Ic&piJL&F;u^$cjmQnXS^RF$Ti zN{<20N`^Uacr_#D%D{#GG_6XqP`yFTmByylD_17@1J}x%O8VFw3ZsZwFPrc^S)d|& z`tSk;R;W8QVE#k0P~32nh$DV{x8Gwx7h;pa<`B?)4U|PXuvC*WRU`uhYZ7RvAnL}! z;(>1^18&l)Nm)GzC%3``3iX7jOGMXt9nd5gfZ_S3M#nm==ph1Fos2nw};fOW`{FR(62;id1 zC}`_J(3M4t0OmpFIZSmS%}k5N`Dk*A4mpR%iH|JnVsJ4rQJ{R^yTA*4ugD*r0|?YhdLQz330le zsP}XGfWxD)C@H%DUP7$uOsKOkE|d67I-Amx`U_|pNK#WwCO|j!jdepq1GBSJ^K(-J z{XM0{MS*}1^=2m2_v+E_Q>;NNz8Q3~fh)nL2%dtnQ!F(%nT_Zi@rC@gjdiV^ZRj*u z-Hi_XrJcK07MHgUj0`umwpP?sqgfl8{-9YN)+rhAeSE9nusb|1kKgAHhYE@d<5lI= zbyZ~*@kl|~Osz1;sOfx!MOPe)(`iTZ=8B4vme%_Ifu8ZrBeU~Ui%WA;vlBgi-8FSp(OAgg z63v`}A#%864+w@-G^<4N@sUEesUjKKx(=GF_ikOja^cf+AD=&W?(XfYH?Cc{c=5xPolD(aZN}UC!E7SG!eJk#b7W{QB~g6-7z(_dFRe;yZ5YYSzZ_!8)|NCj1@)E zepF^gC6(1nQVk_ULMA#l4;?&m5bPafR< z?%|!UZ(lwC$(cj@S9*FnO5(*%x65Rq?r z`(r#s4+f(wmog=RDcEtm(eALtio&%Gm2K_Kt*y;-v$J1Z`s~)tFV1~@dh3??w$^5! z&ug{um{!WodqPZnA%9V`*93;dUC$Ce#%g zInM5M7MGN?wYLrqZmg@XjTIHR+zxOkW6hz$=1dwOaUEe(MqpFm2=Kb%WhH}yeaDX< z`1I2c&wu{W(c}BO`?~x=A3DPIR1hMsGg?)X*=j*oiiYOe#if}KKRR{i&egkjudeRe z(cRr1iAG52MoOYUYzCe?Y~`auDXR_F=M!kNfsqR6l-q4DDvk~hb{{{o`}vdGKR>(w z^x^F*mptF93 z{r5XFzwRA76Zemb#%imsOkm0cwp?W6Hm1VHHi*Vfr+K4??{V4cY{odx6!UC}VDcHY z9spB%AJ4iuy}+uhjLHJV_%NGdlGv1uRR=gGVqrWc9ml8)DYf~u$w^a^r%zFpFF9jM z$)?nq*i>@nxjNy_`|}M4OsQl%1&vUteCg-^cQ!>^!ic9pRq047k7}hbiOT*%g!LC1 z^#JCelNT4JG{Id$$?UAxs~HA$mHFh)QGSxC$p9yfO=UFhr3k7(#_vB5Zj7c369U33b#Y%Y&x0R&+YuK`X<*O7|JaI4n@CH$DED%B^38;Y8;LNBzb#AUY7q$%QS`9iHcnjbUhxc0U#HS3Es1kiC-hWW#$e!i-sktA369I{676=k z+g;yS*VNolSy>(o_)O@pXwbz@OP~`;Mj|*OF`AWd1j!U-uu+;A`p}=(=yhl~>u|dZ zii`RN2hN=R;KOqtUA}tp%!jAPH*G2`Dt39?s9Qt7#u{FMkp8EEcoDJYJKF1v|0qq&!f49`d{y-|J%hcI^HbY* zZQFl%@8M$yR(5Zno}29K?kFpZqsb;3CmX1Os-yrIY9$As zWb0EziYeI?9C0d@Dj)VN+-f(7cA=)WqHkm8^z`_)?F*~Bw{6?8G`~2Dwh}rR!UZ9; zPxK5yY}ynmB_SzI((xdJsib6~6i|boG(lRmH{hwLijR#A9@@X_>ZMPfKfV9`lY8Gi zyz}szTi@Kj_2lV;hmXIxbn(*3<0p?E-9JA+QC(B+@w+(QL@5Wovkypyl(&=b@=J}( zVj%b2U@)L1QM5U>e;KGAK$rk`Q$r?CpM48 z%SzEGf;Afri7au%7%S)2FVfhpL=U^1cF-x}f;fqL8_~W zU7RclIcFFKokeKGfIeY#Z20iugGY}ZnVOv7Eu0>(ya9WGjViSctxZK``TXMa`)7`y zJNIrweYL}3GZ?72l##X%QE4jKlny;<1Up`&AUr%WaQvM^4<6ip{`B6VgS)%B+5$nZ z9`Xbd$@7G*;ed4XTPC;9GdQ^M(xp$IKY#G>(Vh3toapNAK!*g{N+y7MJV}d!YK6FH zBWFvnDdOFeGtVJ!%8ItH(QdakH&yT5z4hC>SAT!~?DyY)dUXHBk%RkMTiZmt3&Q1b z4iRc*ybEZw6xN{PR1I2=f##VfoA{L3<^WQ3Dw(CzgmZPCgj`5S1(r(@HkF*kB(o_w zwJAUUPuAT_V^eDtj#q#t`5}#+`ES@%itjHcISwm{O-Wxf54T)2*+Fv+yF=iu^yak! zOsU8+j+s)C@_cl|%30_PEz&3HUG<533No9rNNfs6prb!0((rQvrW}5sD;V^KqTX0> zu)I7rwRzy|nPWdZz5lP*-@pF(>8qa!n*tLbmPg z!m>cL$QO=yaQHd80@~dU!C}W`AVqu-LRCJ_%0VOXag~Z ze?Kwx+u@0)6KyjVO{+y$VbzyW(G>b*eXVF{bDH}++<=E~5lodlQ_3^NHbaQhI~bLZ zWBnF`$IJ)@HP5Jc%%-I9bG129q)+WMs$;ytk3~~Py~@By5$F<|QbbEp7?mi=m*nPy z*mIn7o}-bQ#G~W|l@d?oD@*eI0g}p3IQU5TIejRxshlJ#l_xp)r0{bYHzj%clGzld zOsQ;2+5UhdfsZdcH^s#FSCh|E{DY7#m4k+S=rlx=0?{d;!(M~CL^NB>&CQmvSbD~k zl!Bg-(yS>ZN@r8aK0CsH)}^qiOgQK-v#B)n^aqS9lZ-0;JsG~W%%(t)rpaYZdR)JT zMGN4ll6X`Wjz-UxK~^p#O`-15AM&AziQcH!vYJp7^J%6a>Z8!y1pHPSz)<); zi;6X9iI*)`l?xgwd}D>sA=H`YsdBVvTn!PCkQU{1Ltz@hDLA|it7yS@vb4lM2$4`E zrV02DgD&5IjBw5{gMQs?v^hjb%4KM2bNBDZ7>-6pHjVZ64|eo!Z0_i(YwoOW=%}h~_4vYQ$OR``P8Nwy0@)As@vU1&coa$e zPQ;!klBS6ID>om|9Qxu|OO~INot2f7*dVftP&UnBBVl%Key+i6Ku3iq0J04M4d%^g zzZ$Kg5R8UAK_7>6O^uw%D%#BGiV261h%TwTXw|ZCz!0ShI8U`2JY%J$+x7UCtDJ|d z$3+n%*%W z7bk-vmV~?FoHuwC6iulA0oT1MU#nK@=^+7(Kux33^U41{%Hv?hzm?s9m1o|4kyq2a#e?ejZUwhRvR z)znl30$v_XZ(w7!!JP2xN9E+wV{(u)v$2z+@m$z>_ zb>`IjXWu{c&f%%Wxq;E)%G&C1K@@y*9B5UEV2i|4GZ5{<2@Y4Rq_m}@V`THDiMi?a z-tLmha+lw0;w@;VhQ5df?oGf9jx|z=K9Oy}EeRaqZQ}VrG*VSxH!?ZCxMS<`?j3X6 z7B`Lz#H-3YelG`ROg)(v$vB043s9M90U@Cs$=ii+abaysQ~&tL)Ry^edv@(Ta$x_l z1FQR2=ay#s2D(eii`;GphgKVNES)|<>WHpM%1eRxK{Q7WM#5FKH9h?sXBX%89^Cid z2d9s{dwlo)Ju?flUA^70;+WIzGUI|B*z`xy7TMZx7lYLA(@F8>I<*2rsbzaOc}c3x zC(r)WO5GG%VKl{v6-HWG>c_?gmzL%Z9N4{o|E_J@7dLGlX=`te#v)iU#OfrvrM$fk zf~&NLl3V~`L7u)!OS904tS(Wfn=wkoL`XqHwA&cVO?foy$FaJ!KW;UZ2-uu`n1JNV(rM z>poFj&tyng*wUL^nU1Q$^hy?|DCI^>cp$3N;&?Z~E`Vq4=)oVJefPuj$9KQFcJ{+l zJ9lj9Xm1IH{eYxQ5SU^>hnj^%WFAYTvV1%%PCKudnmqfz`_wK6>=+t=F%f{`%_a{X188?bzaRIyoFx zkKObf)ER*cWQ%0q!-_a;977+9IxMH#SzS{#JG=SA58iqF;Ld-3|M@@v`tjN0dlx@F zyRamHzrj~k#(}C@r^wU^2VSgq)Emlv#QK3aWy@}-o zYrL#v`||va>la?Wd~)xbYjX<|#icPpv|`6G@I z_0{)RuU^=;eW|XY*5PtuXEcpE$B9xFGmYzkx_q?i84n9+9BUH$?h7WxkhuzlF zRP+9+BTv4)_4~_b|9biS=VuR2ojB3n+V1lOIbPtb0z^w$u!+wCd1a&qAIX)XS}EB} zE<4R-F($8iLAh#AYSYlo3auOWmm%BFA}%nG!^c-C=b)1frPod7S~jI~4L^#Z;iaHoj+N@!st# zuYP_4fE}x(UcUJ56>h)2diL9^?|=LCryqZO_UY#r21X~M#Z{5Q@?b%UKU&}k1wDSh z%j*L$<#Ga;a@eg9ehwK^_@K3r_&9pgfumH)Bt^hs8L1*s$|!5OiNRcfr-({Q$)lLe zc*bakg%z+g(%oC@oh3^V$7smj6Be4>T)mU4wOeXLu97!2xwyfAIOnnMb8_bb{I9EBzn$Ft z`snn-*}h{1-WIc}iU%+S&Bnxerq;%`JI%cw%SI31=`>dghPY@f6pcYn?_dE;1uO

`VWry|}x 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 z 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

%rPd8px7qM%_Li4Y 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

^J!b#_v4utanHtBI~}zS;Ez;LuZqNOhO9 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±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%0Dw>f-__S?uCPF)|0%Z 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 v|gjQNn&<@vyt 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�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

qsX*+Fc6Oez3n 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