@paraswap/dex-lib 3.3.0 → 3.3.1-return-amount-pos.1

package/build/abi/trader-joe-v2_1/StateMulticall.json

@@ -1,193 +0,0 @@
-[
-    {
-        "inputs": [
-            {
-                "internalType": "address",
-                "name": "factoryAddress",
-                "type": "address"
-            },
-            {
-                "internalType": "contract IERC20",
-                "name": "tokenIn",
-                "type": "address"
-            },
-            {
-                "internalType": "contract IERC20",
-                "name": "tokenOut",
-                "type": "address"
-            },
-            {
-                "internalType": "uint24",
-                "name": "binStep",
-                "type": "uint24"
-            }
-        ],
-        "name": "getFullState",
-        "outputs": [
-            {
-                "components": [
-                    {
-                        "internalType": "contract ILBPair",
-                        "name": "pair",
-                        "type": "address"
-                    },
-                    {
-                        "components": [
-                            {
-                                "internalType": "uint24",
-                                "name": "id",
-                                "type": "uint24"
-                            },
-                            {
-                                "internalType": "uint128",
-                                "name": "reserveX",
-                                "type": "uint128"
-                            },
-                            {
-                                "internalType": "uint128",
-                                "name": "reserveY",
-                                "type": "uint128"
-                            }
-                        ],
-                        "internalType": "struct ITraderJoeV21StateMulticall.Bin[]",
-                        "name": "bins",
-                        "type": "tuple[]"
-                    },
-                    {
-                        "internalType": "address",
-                        "name": "tokenX",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "address",
-                        "name": "tokenY",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "address",
-                        "name": "pairAddress",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "uint256",
-                        "name": "blockTimestamp",
-                        "type": "uint256"
-                    },
-                    {
-                        "components": [
-                            {
-                                "internalType": "uint128",
-                                "name": "reserveX",
-                                "type": "uint128"
-                            },
-                            {
-                                "internalType": "uint128",
-                                "name": "reserveY",
-                                "type": "uint128"
-                            }
-                        ],
-                        "internalType": "struct ITraderJoeV21StateMulticall.Reserves",
-                        "name": "reserves",
-                        "type": "tuple"
-                    },
-                    {
-                        "internalType": "uint24",
-                        "name": "activeId",
-                        "type": "uint24"
-                    },
-                    {
-                        "components": [
-                            {
-                                "internalType": "uint128",
-                                "name": "protocolFeeX",
-                                "type": "uint128"
-                            },
-                            {
-                                "internalType": "uint128",
-                                "name": "protocolFeeY",
-                                "type": "uint128"
-                            }
-                        ],
-                        "internalType": "struct ITraderJoeV21StateMulticall.ProtocolFees",
-                        "name": "protocolFees",
-                        "type": "tuple"
-                    },
-                    {
-                        "components": [
-                            {
-                                "internalType": "uint16",
-                                "name": "baseFactor",
-                                "type": "uint16"
-                            },
-                            {
-                                "internalType": "uint16",
-                                "name": "filterPeriod",
-                                "type": "uint16"
-                            },
-                            {
-                                "internalType": "uint16",
-                                "name": "decayPeriod",
-                                "type": "uint16"
-                            },
-                            {
-                                "internalType": "uint16",
-                                "name": "reductionFactor",
-                                "type": "uint16"
-                            },
-                            {
-                                "internalType": "uint24",
-                                "name": "variableFeeControl",
-                                "type": "uint24"
-                            },
-                            {
-                                "internalType": "uint16",
-                                "name": "protocolShare",
-                                "type": "uint16"
-                            },
-                            {
-                                "internalType": "uint24",
-                                "name": "maxVolatilityAccumulator",
-                                "type": "uint24"
-                            }
-                        ],
-                        "internalType": "struct ITraderJoeV21StateMulticall.StaticFeeParameters",
-                        "name": "staticFeeParameters",
-                        "type": "tuple"
-                    },
-                    {
-                        "components": [
-                            {
-                                "internalType": "uint24",
-                                "name": "volatilityAccumulator",
-                                "type": "uint24"
-                            },
-                            {
-                                "internalType": "uint24",
-                                "name": "volatilityReference",
-                                "type": "uint24"
-                            },
-                            {
-                                "internalType": "uint24",
-                                "name": "idReference",
-                                "type": "uint24"
-                            },
-                            {
-                                "internalType": "uint40",
-                                "name": "timeOfLastUpdate",
-                                "type": "uint40"
-                            }
-                        ],
-                        "internalType": "struct ITraderJoeV21StateMulticall.VariableFeeParameters",
-                        "name": "variableFeeParameters",
-                        "type": "tuple"
-                    }
-                ],
-                "internalType": "struct ITraderJoeV21StateMulticall.StateResult",
-                "name": "state",
-                "type": "tuple"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    }
-]

package/build/dex/angle-transmuter/angle-transmuter-pool.d.ts

@@ -1,61 +0,0 @@
-import { Interface } from '@ethersproject/abi';
-import { Address, Logger } from '../../types';
-import { ComposedEventSubscriber } from '../../composed-event-subscriber';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { ChainlinkConfig, MorphoConfig, OracleFeed, OracleQuoteType, OracleReadType, PoolConfig, PoolState, PythConfig, TransmuterParams } from './types';
-import { Contract } from 'web3-eth-contract';
-import { SwapSide } from '../../constants';
-export declare class AngleTransmuterEventPool extends ComposedEventSubscriber<PoolState> {
-    readonly parentName: string;
-    protected network: number;
-    protected dexHelper: IDexHelper;
-    transmuter: Contract;
-    static angleTransmuterIface: Interface;
-    readonly config: PoolConfig;
-    constructor(parentName: string, network: number, dexHelper: IDexHelper, logger: Logger, config: PoolConfig);
-    getStateOrGenerate(blockNumber: number): Promise<Readonly<PoolState>>;
-    getAmountOut(_tokenIn: Address, _tokenOut: Address, side: SwapSide, _amounts: number[], blockNumber: number): Promise<number[] | null>;
-    static getCollateralsList(transmuterAddress: Address, blockNumber: number | 'latest', multiContract: Contract): Promise<string[]>;
-    static _fillMap(chainlinkMap: ChainlinkConfig, backedMap: ChainlinkConfig, redstoneMap: ChainlinkConfig, pythIds: PythConfig, morphoMap: MorphoConfig, oracleFeed: OracleFeed, blockNumber: number | 'latest', multiContract: Contract): Promise<{
-        chainlinkMap: ChainlinkConfig;
-        backedMap: ChainlinkConfig;
-        redstoneMap: ChainlinkConfig;
-        pythIds: PythConfig;
-        morphoMap: MorphoConfig;
-    }>;
-    static generateStateChainlinkLike(feed: string, chainlinkMap: ChainlinkConfig, backedMap: ChainlinkConfig, redstoneMap: ChainlinkConfig, blockNumber: number | 'latest', multiContract: Contract): Promise<{
-        chainlinkMap: ChainlinkConfig;
-        backedMap: ChainlinkConfig;
-        redstoneMap: ChainlinkConfig;
-    }>;
-    static getOraclesConfig(transmuterAddress: Address, pythAddress: Address, collaterals: Address[], blockNumber: number | 'latest', multiContract: Contract): Promise<{
-        chainlink: ChainlinkConfig;
-        backed: ChainlinkConfig;
-        redstone: ChainlinkConfig;
-        pyth: PythConfig;
-        morpho: MorphoConfig;
-    }>;
-    static getConfig(dexParams: TransmuterParams, blockNumber: number | 'latest', multiContract: Contract): Promise<PoolConfig>;
-    _readMint(config: PoolConfig, state: PoolState, collateral: Address, blockNumber: number): number;
-    _getBurnOracle(config: PoolConfig, state: PoolState, collateral: Address, blockNumber: number): {
-        oracleValue: number;
-        minRatio: number;
-    };
-    _readBurn(config: PoolConfig, state: PoolState, collateral: Address, blockNumber: number): {
-        oracleValue: number;
-        ratio: number;
-    };
-    _readSpotAndTarget(config: PoolConfig, state: PoolState, collateral: Address, blockNumber: number): {
-        spot: number;
-        target: number;
-        userDeviation: number;
-        burnRatioDeviation: number;
-    };
-    _quoteAmount(quoteType: OracleQuoteType, baseValue: number): number;
-    _read(config: PoolConfig, state: PoolState, oracleType: OracleReadType, feed: OracleFeed, baseValue: number): number;
-    _readChainlink(config: PoolConfig, state: PoolState, id: string, isMultiplied: number, price: number): {
-        price: number;
-        decimals: number;
-    };
-    _readMorphoFeedChainlink(config: PoolConfig, state: PoolState, id: string): bigint;
-}

package/build/dex/angle-transmuter/angle-transmuter-pool.js

@@ -1,415 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AngleTransmuterEventPool = void 0;
-const abi_1 = require("@ethersproject/abi");
-const lens_1 = require("../../lens");
-const composed_event_subscriber_1 = require("../../composed-event-subscriber");
-const chainlink_1 = require("../../lib/chainlink");
-const types_1 = require("./types");
-const Transmuter_json_1 = __importDefault(require("../../abi/angle-transmuter/Transmuter.json"));
-const transmuter_1 = require("./transmuter");
-const pyth_1 = require("./pyth");
-const utils_1 = require("./utils");
-const redstone_1 = require("./redstone");
-const utils_2 = require("ethers/lib/utils");
-const backedOracle_1 = require("./backedOracle");
-const constants_1 = require("../../constants");
-const ethers_1 = require("ethers");
-const constants_2 = require("./constants");
-const morphoOracle_1 = require("./morphoOracle");
-const utils_3 = require("../../utils");
-const morphoVault_1 = require("./morphoVault");
-class AngleTransmuterEventPool extends composed_event_subscriber_1.ComposedEventSubscriber {
-    constructor(parentName, network, dexHelper, logger, config) {
-        const chainlinkMap = Object.entries(config.oracles.chainlink).reduce((acc, [key, value]) => {
-            acc[key] = new chainlink_1.ChainLinkSubscriber(value.proxy, value.aggregator, (0, lens_1.lens)().oracles.chainlink[key], dexHelper.getLogger(`${key} ChainLink for ${parentName}-${network}`));
-            return acc;
-        }, {});
-        const backedMap = Object.entries(config.oracles.backed).reduce((acc, [key, value]) => {
-            acc[key] = new backedOracle_1.BackedSubscriber(value.proxy, value.aggregator, (0, lens_1.lens)().oracles.chainlink[key], dexHelper.getLogger(`${key} ChainLink for ${parentName}-${network}`));
-            return acc;
-        }, {});
-        const redstoneMap = Object.entries(config.oracles.redstone).reduce((acc, [key, value]) => {
-            acc[key] = new redstone_1.RedstoneSubscriber(value.proxy, value.aggregator, (0, lens_1.lens)().oracles.chainlink[key], dexHelper.getLogger(`${key} ChainLink for ${parentName}-${network}`));
-            return acc;
-        }, {});
-        const morphoMap = Object.entries(config.oracles.morpho).reduce((acc, [key, value]) => {
-            if (value.baseVault && value.baseVault !== ethers_1.ethers.constants.AddressZero)
-                acc[value.baseVault] = new morphoVault_1.MorphoVaultSubscriber(value.baseVault, (0, lens_1.lens)().oracles.morphoVault[value.baseVault], dexHelper.getLogger(`${key}:${value.baseVault} Morpho Vault for ${parentName}-${network}`));
-            if (value.quoteVault &&
-                value.quoteVault !== ethers_1.ethers.constants.AddressZero)
-                acc[value.quoteVault] = new morphoVault_1.MorphoVaultSubscriber(value.quoteVault, (0, lens_1.lens)().oracles.morphoVault[value.quoteVault], dexHelper.getLogger(`${key}:${value.quoteVault} Morpho Vault for ${parentName}-${network}`));
-            return acc;
-        }, {});
-        const pythListener = new pyth_1.PythSubscriber(config.oracles.pyth.proxy, config.oracles.pyth.ids, (0, lens_1.lens)().oracles.pyth, dexHelper.getLogger(`Pyth for ${parentName}-${network}`));
-        const transmuterListener = new transmuter_1.TransmuterSubscriber(config.stablecoin.address, config.transmuter, config.collaterals, (0, lens_1.lens)().transmuter, dexHelper.getLogger(`${parentName}-${network} Transmuter`));
-        super(parentName, 'Transmuter', dexHelper.getLogger(`${parentName}-${network}`), dexHelper, [
-            ...Object.values(chainlinkMap),
-            ...Object.values(backedMap),
-            ...Object.values(redstoneMap),
-            ...Object.values(morphoMap),
-            transmuterListener,
-            pythListener,
-        ], {
-            stablecoin: config.stablecoin,
-            transmuter: {},
-            oracles: { chainlink: {}, pyth: {}, morphoVault: {} },
-        });
-        this.parentName = parentName;
-        this.network = network;
-        this.dexHelper = dexHelper;
-        this.transmuter = new this.dexHelper.web3Provider.eth.Contract(Transmuter_json_1.default, config.transmuter);
-        this.config = config;
-    }
-    async getStateOrGenerate(blockNumber) {
-        const evenState = this.getState(blockNumber);
-        if (evenState)
-            return evenState;
-        const onChainState = await this.generateState(blockNumber);
-        this.setState(onChainState, blockNumber);
-        return onChainState;
-    }
-    // Reference to the original implementation
-    // https://github.com/AngleProtocol/angle-transmuter/blob/6e1f2eb1f961d6c3b1cdaefe068d967c33c41936/contracts/transmuter/facets/Swapper.sol#L177
-    async getAmountOut(_tokenIn, _tokenOut, side, _amounts, blockNumber) {
-        const state = await this.getStateOrGenerate(blockNumber);
-        const isMint = _tokenOut === state.stablecoin.address;
-        let oracleValue;
-        let minRatio = 0;
-        let collateral = _tokenIn;
-        if (isMint)
-            oracleValue = await this._readMint(this.config, state, _tokenIn, blockNumber);
-        else {
-            collateral = _tokenOut;
-            ({ oracleValue, minRatio } = await this._getBurnOracle(this.config, state, _tokenOut, blockNumber));
-        }
-        const collatStablecoinIssued = state.transmuter.collaterals[collateral].stablecoinsIssued;
-        const otherStablecoinIssued = state.transmuter.totalStablecoinIssued - collatStablecoinIssued;
-        const fees = state.transmuter.collaterals[collateral].fees;
-        return _amounts.map(_amount => {
-            if (isMint && side === constants_1.SwapSide.SELL)
-                return (0, utils_1._quoteMintExactInput)(oracleValue, _amount, fees, collatStablecoinIssued, otherStablecoinIssued);
-            if (isMint && side === constants_1.SwapSide.BUY)
-                return (0, utils_1._quoteMintExactOutput)(oracleValue, _amount, fees, collatStablecoinIssued, otherStablecoinIssued);
-            if (!isMint && side === constants_1.SwapSide.SELL)
-                return (0, utils_1._quoteBurnExactInput)(oracleValue, minRatio, _amount, fees, collatStablecoinIssued, otherStablecoinIssued);
-            return (0, utils_1._quoteBurnExactOutput)(oracleValue, minRatio, _amount, fees, collatStablecoinIssued, otherStablecoinIssued);
-        });
-    }
-    static async getCollateralsList(transmuterAddress, blockNumber, multiContract) {
-        const tokensResult = (await multiContract.methods
-            .aggregate([
-            {
-                target: transmuterAddress,
-                callData: transmuter_1.TransmuterSubscriber.interface.encodeFunctionData('getCollateralList'),
-            },
-        ])
-            .call({}, blockNumber)).returnData;
-        const tokens = transmuter_1.TransmuterSubscriber.interface.decodeFunctionResult('getCollateralList', tokensResult[0])[0];
-        // .map((t: any) => t.toLowerCase());
-        return tokens;
-    }
-    static async _fillMap(chainlinkMap, backedMap, redstoneMap, pythIds, morphoMap, oracleFeed, blockNumber, multiContract) {
-        if (oracleFeed.isChainlink) {
-            await Promise.all(oracleFeed.chainlink.circuitChainlink.map(async (feed) => {
-                ({ chainlinkMap, backedMap, redstoneMap } =
-                    await AngleTransmuterEventPool.generateStateChainlinkLike(feed, chainlinkMap, backedMap, redstoneMap, blockNumber, multiContract));
-            }));
-        }
-        else if (oracleFeed.isPyth) {
-            pythIds.ids = pythIds.ids.concat(oracleFeed.pyth.feedIds);
-        }
-        else if (oracleFeed.isMorpho) {
-            const morphoOracleResult = (await multiContract.methods
-                .aggregate(morphoOracle_1.MorphoOracleEventPool.getGenerateInfoMultiCallInput(oracleFeed.morpho.oracle))
-                .call({}, blockNumber)).returnData;
-            const morphoOracleInfo = morphoOracle_1.MorphoOracleEventPool.generateInfo(morphoOracleResult);
-            if (morphoOracleInfo.baseFeed1 !== ethers_1.ethers.constants.AddressZero)
-                ({ chainlinkMap, backedMap, redstoneMap } =
-                    await AngleTransmuterEventPool.generateStateChainlinkLike(morphoOracleInfo.baseFeed1, chainlinkMap, backedMap, redstoneMap, blockNumber, multiContract));
-            if (morphoOracleInfo.baseFeed2 !== ethers_1.ethers.constants.AddressZero)
-                ({ chainlinkMap, backedMap, redstoneMap } =
-                    await AngleTransmuterEventPool.generateStateChainlinkLike(morphoOracleInfo.baseFeed2, chainlinkMap, backedMap, redstoneMap, blockNumber, multiContract));
-            if (morphoOracleInfo.quoteFeed1 !== ethers_1.ethers.constants.AddressZero)
-                ({ chainlinkMap, backedMap, redstoneMap } =
-                    await AngleTransmuterEventPool.generateStateChainlinkLike(morphoOracleInfo.quoteFeed1, chainlinkMap, backedMap, redstoneMap, blockNumber, multiContract));
-            if (morphoOracleInfo.quoteFeed2 !== ethers_1.ethers.constants.AddressZero)
-                ({ chainlinkMap, backedMap, redstoneMap } =
-                    await AngleTransmuterEventPool.generateStateChainlinkLike(morphoOracleInfo.quoteFeed2, chainlinkMap, backedMap, redstoneMap, blockNumber, multiContract));
-            morphoMap[oracleFeed.morpho.oracle] = morphoOracleInfo;
-        }
-        else {
-            throw new Error('Unknown oracle feed');
-        }
-        return { chainlinkMap, backedMap, redstoneMap, pythIds, morphoMap };
-    }
-    static async generateStateChainlinkLike(feed, chainlinkMap, backedMap, redstoneMap, blockNumber, multiContract) {
-        let aggreagator;
-        let decimals;
-        // it can be Chainlink or Redstone feed
-        // if the call getReadAggregatorMultiCallInput fail with a Chainlink instance
-        // then it is a Redstone one
-        try {
-            // Chainlink
-            const proxyResult = (await multiContract.methods
-                .aggregate([
-                chainlink_1.ChainLinkSubscriber.getReadAggregatorMultiCallInput(feed),
-                chainlink_1.ChainLinkSubscriber.getReadDecimal(feed),
-            ])
-                .call({}, blockNumber)).returnData;
-            aggreagator = chainlink_1.ChainLinkSubscriber.readAggregator(proxyResult[0]);
-            decimals = Number(chainlink_1.ChainLinkSubscriber.readDecimals(proxyResult[1]));
-            chainlinkMap[feed] = {
-                proxy: feed,
-                aggregator: aggreagator,
-                decimals: decimals,
-            };
-        }
-        catch {
-            try {
-                // Redstone
-                const proxyResult = (await multiContract.methods
-                    .aggregate([
-                    redstone_1.RedstoneSubscriber.getReadAggregatorMultiCallInput(feed),
-                    redstone_1.RedstoneSubscriber.getReadDecimal(feed),
-                ])
-                    .call({}, blockNumber)).returnData;
-                aggreagator = redstone_1.RedstoneSubscriber.readAggregator(proxyResult[0]);
-                decimals = Number(redstone_1.RedstoneSubscriber.readDecimals(proxyResult[1]));
-                redstoneMap[feed] = {
-                    proxy: feed,
-                    aggregator: aggreagator,
-                    decimals: decimals,
-                };
-            }
-            catch {
-                // Backed
-                const proxyResult = (await multiContract.methods
-                    .aggregate([chainlink_1.ChainLinkSubscriber.getReadDecimal(feed)])
-                    .call({}, blockNumber)).returnData;
-                decimals = Number(chainlink_1.ChainLinkSubscriber.readDecimals(proxyResult[0]));
-                backedMap[feed] = {
-                    proxy: feed,
-                    aggregator: feed,
-                    decimals: decimals,
-                };
-            }
-        }
-        return { chainlinkMap, backedMap, redstoneMap };
-    }
-    static async getOraclesConfig(transmuterAddress, pythAddress, collaterals, blockNumber, multiContract) {
-        const getOracleConfigData = collaterals.map(collat => {
-            return {
-                callData: transmuter_1.TransmuterSubscriber.interface.encodeFunctionData('getOracle', [collat]),
-                target: transmuterAddress,
-            };
-        });
-        const oracleConfigResult = (await multiContract.methods
-            .aggregate(getOracleConfigData)
-            .call({}, blockNumber)).returnData;
-        const oracleConfigs = oracleConfigResult.map((p) => transmuter_1.TransmuterSubscriber.interface.decodeFunctionResult('getOracle', p));
-        let chainlinkMap = {};
-        let backedMap = {};
-        let redstoneMap = {};
-        let pythIds = { proxy: pythAddress, ids: [] };
-        let morphoMap = {};
-        await Promise.all(oracleConfigs.map(async (oracleConfigDecoded) => {
-            if (oracleConfigDecoded.oracleType !== types_1.OracleReadType.EXTERNAL) {
-                // add all the feed oracles used to their respective channels
-                if (oracleConfigDecoded.oracleType === types_1.OracleReadType.CHAINLINK_FEEDS ||
-                    oracleConfigDecoded.oracleType === types_1.OracleReadType.PYTH ||
-                    oracleConfigDecoded.oracleType === types_1.OracleReadType.MORPHO_ORACLE) {
-                    const oracleFeed = transmuter_1.TransmuterSubscriber._decodeOracleFeed(oracleConfigDecoded.oracleType, oracleConfigDecoded.oracleData);
-                    ({ chainlinkMap, backedMap, redstoneMap, pythIds, morphoMap } =
-                        await AngleTransmuterEventPool._fillMap(chainlinkMap, backedMap, redstoneMap, pythIds, morphoMap, oracleFeed, blockNumber, multiContract));
-                }
-                if (oracleConfigDecoded.targetType === types_1.OracleReadType.CHAINLINK_FEEDS ||
-                    oracleConfigDecoded.targetType === types_1.OracleReadType.PYTH ||
-                    oracleConfigDecoded.targetType === types_1.OracleReadType.MORPHO_ORACLE) {
-                    const oracleFeed = transmuter_1.TransmuterSubscriber._decodeOracleFeed(oracleConfigDecoded.targetType, oracleConfigDecoded.targetData);
-                    ({ chainlinkMap, backedMap, redstoneMap, pythIds, morphoMap } =
-                        await AngleTransmuterEventPool._fillMap(chainlinkMap, backedMap, redstoneMap, pythIds, morphoMap, oracleFeed, blockNumber, multiContract));
-                }
-            }
-        }));
-        return {
-            chainlink: chainlinkMap,
-            backed: backedMap,
-            redstone: redstoneMap,
-            pyth: pythIds,
-            morpho: morphoMap,
-        };
-    }
-    static async getConfig(dexParams, blockNumber, multiContract) {
-        const collaterals = await AngleTransmuterEventPool.getCollateralsList(dexParams.transmuter, blockNumber, multiContract);
-        // get all oracles feed
-        const oracles = await AngleTransmuterEventPool.getOraclesConfig(dexParams.transmuter, dexParams.pyth, collaterals, blockNumber, multiContract);
-        return {
-            stablecoin: dexParams.stablecoin,
-            transmuter: dexParams.transmuter,
-            collaterals: collaterals,
-            oracles: oracles,
-        };
-    }
-    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                         UTILS
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
-    _readMint(config, state, collateral, blockNumber) {
-        const configOracle = state.transmuter.collaterals[collateral].config;
-        if (configOracle.oracleType === types_1.OracleReadType.EXTERNAL) {
-            return 1;
-        }
-        let target;
-        let spot;
-        ({ spot, target } = this._readSpotAndTarget(config, state, collateral, blockNumber));
-        if (target < spot)
-            spot = target;
-        return spot;
-    }
-    _getBurnOracle(config, state, collateral, blockNumber) {
-        return config.collaterals.reduce((acc, comparedCollat, j) => {
-            let ratio;
-            if (comparedCollat.toLowerCase() === collateral.toLowerCase()) {
-                let oracleValue;
-                ({ oracleValue, ratio } = this._readBurn(config, state, comparedCollat, blockNumber));
-                acc.oracleValue = oracleValue;
-            }
-            else
-                ({ ratio } = this._readBurn(config, state, comparedCollat, blockNumber));
-            if (ratio < acc.minRatio)
-                acc.minRatio = ratio;
-            return acc;
-        }, { oracleValue: 0, minRatio: 1 });
-    }
-    _readBurn(config, state, collateral, blockNumber) {
-        const configOracle = state.transmuter.collaterals[collateral].config;
-        if (configOracle.oracleType === types_1.OracleReadType.EXTERNAL) {
-            return { oracleValue: 1, ratio: 1 };
-        }
-        let spot;
-        let target;
-        let burnRatioDeviation;
-        ({ spot, target, burnRatioDeviation } = this._readSpotAndTarget(config, state, collateral, blockNumber));
-        let ratio = 1;
-        if (spot < target * (1 - burnRatioDeviation))
-            ratio = spot / target;
-        else if (spot < target)
-            spot = target;
-        return { oracleValue: spot, ratio };
-    }
-    _readSpotAndTarget(config, state, collateral, blockNumber) {
-        const configOracle = state.transmuter.collaterals[collateral].config;
-        let userDeviation = 0;
-        let burnRatioDeviation = 0;
-        if (constants_2.BLOCK_UPGRADE_ORACLE <= blockNumber) {
-            const hyperparameters = (0, utils_1.filterDictionaryOnly)(ethers_1.ethers.utils.defaultAbiCoder.decode(['uint128 userDeviation', 'uint128 burnRatioDeviation'], configOracle.hyperparameters));
-            userDeviation = Number.parseFloat((0, utils_2.formatEther)(hyperparameters.userDeviation.toString()));
-            burnRatioDeviation = Number.parseFloat((0, utils_2.formatEther)(hyperparameters.burnRatioDeviation.toString()));
-        }
-        const targetPrice = this._read(config, state, configOracle.targetType, configOracle.targetFeed, 1);
-        let oracleValue = this._read(config, state, configOracle.oracleType, configOracle.oracleFeed, targetPrice);
-        if (targetPrice * (1 - userDeviation) < oracleValue &&
-            oracleValue < targetPrice * (1 + userDeviation))
-            oracleValue = targetPrice;
-        return {
-            spot: oracleValue,
-            target: targetPrice,
-            userDeviation,
-            burnRatioDeviation,
-        };
-    }
-    _quoteAmount(quoteType, baseValue) {
-        if (quoteType === types_1.OracleQuoteType.UNIT)
-            return 1;
-        return baseValue;
-    }
-    _read(config, state, oracleType, feed, baseValue) {
-        let price = 1;
-        if (oracleType === types_1.OracleReadType.CHAINLINK_FEEDS) {
-            price = this._quoteAmount(feed.chainlink.quoteType, baseValue);
-            for (let i = 0; i < feed.chainlink.circuitChainlink.length; i++) {
-                ({ price } = this._readChainlink(config, state, feed.chainlink.circuitChainlink[i], feed.chainlink.circuitChainIsMultiplied[i], price));
-            }
-        }
-        else if (oracleType === types_1.OracleReadType.PYTH) {
-            price = this._quoteAmount(feed.pyth.quoteType, baseValue);
-            for (let i = 0; i < feed.pyth.feedIds.length; i++) {
-                const id = feed.pyth.feedIds[i];
-                const rate = state.oracles.pyth[id].answer;
-                if (feed.pyth.isMultiplied[i] === 1)
-                    price *= rate;
-                else
-                    price /= rate;
-            }
-        }
-        else if (oracleType === types_1.OracleReadType.STABLE) {
-            price = 1;
-        }
-        else if (oracleType === types_1.OracleReadType.NO_ORACLE) {
-            price = baseValue;
-        }
-        else if (oracleType == types_1.OracleReadType.MAX) {
-            price = feed.maxValue;
-        }
-        else if (oracleType == types_1.OracleReadType.MORPHO_ORACLE) {
-            const morphoOracleConfig = config.oracles.morpho[feed.morpho.oracle];
-            const baseVaultPrice = morphoOracleConfig.baseVault !== ethers_1.ethers.constants.AddressZero
-                ? (morphoOracleConfig.baseVaultConversion *
-                    state.oracles.morphoVault[morphoOracleConfig.baseVault]
-                        .totalAssets) /
-                    state.oracles.morphoVault[morphoOracleConfig.baseVault].totalSupply
-                : 1n;
-            const quoteVaultPrice = morphoOracleConfig.quoteVault !== ethers_1.ethers.constants.AddressZero
-                ? (morphoOracleConfig.quoteVaultConversion *
-                    state.oracles.morphoVault[morphoOracleConfig.quoteVault]
-                        .totalAssets) /
-                    state.oracles.morphoVault[morphoOracleConfig.quoteVault].totalSupply
-                : 1n;
-            const baseFeed1Price = morphoOracleConfig.baseFeed1 !== ethers_1.ethers.constants.AddressZero
-                ? this._readMorphoFeedChainlink(config, state, morphoOracleConfig.baseFeed1)
-                : 1n;
-            const baseFeed2Price = morphoOracleConfig.baseFeed2 !== ethers_1.ethers.constants.AddressZero
-                ? this._readMorphoFeedChainlink(config, state, morphoOracleConfig.baseFeed2)
-                : 1n;
-            const quoteFeed1Price = morphoOracleConfig.quoteFeed1 !== ethers_1.ethers.constants.AddressZero
-                ? this._readMorphoFeedChainlink(config, state, morphoOracleConfig.quoteFeed1)
-                : 1n;
-            const quoteFeed2Price = morphoOracleConfig.quoteFeed2 !== ethers_1.ethers.constants.AddressZero
-                ? this._readMorphoFeedChainlink(config, state, morphoOracleConfig.quoteFeed2)
-                : 1n;
-            price = Number.parseFloat((0, utils_2.formatUnits)((morphoOracleConfig.scaleFactor *
-                baseVaultPrice *
-                baseFeed1Price *
-                baseFeed2Price) /
-                quoteVaultPrice /
-                quoteFeed1Price /
-                quoteFeed2Price, 36));
-        }
-        return price;
-    }
-    _readChainlink(config, state, id, isMultiplied, price) {
-        let decimals;
-        if (Object.keys(config.oracles.chainlink).includes(id))
-            decimals = config.oracles.chainlink[id].decimals;
-        else if (Object.keys(config.oracles.redstone).includes(id))
-            decimals = config.oracles.redstone[id].decimals;
-        else
-            decimals = config.oracles.backed[id].decimals;
-        const rate = Number.parseFloat((0, utils_2.formatUnits)(state.oracles.chainlink[id].answer.toString(), decimals));
-        if (isMultiplied === 1)
-            price *= rate;
-        else
-            price /= rate;
-        return { price, decimals };
-    }
-    _readMorphoFeedChainlink(config, state, id) {
-        const { price, decimals } = this._readChainlink(config, state, id, 1, 1);
-        return (0, utils_3.bigIntify)((0, utils_2.parseUnits)(price.toString(), decimals));
-    }
-}
-exports.AngleTransmuterEventPool = AngleTransmuterEventPool;
-AngleTransmuterEventPool.angleTransmuterIface = new abi_1.Interface(Transmuter_json_1.default);
-//# sourceMappingURL=angle-transmuter-pool.js.map