@paraswap/dex-lib 2.50.4 → 2.50.5

package/build/dex/angle-staked-stable/config.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Adapters = exports.AngleStakedStableConfig = void 0;
+const constants_1 = require("../../constants");
+exports.AngleStakedStableConfig = {
+    // USDA <-> stUSD
+    AngleStakedStableUSD: {
+        [constants_1.Network.ARBITRUM]: {
+            agToken: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
+            stakeToken: '0x0022228a2cc5E7eF0274A7Baa600d44da5aB5776',
+        },
+        [constants_1.Network.MAINNET]: {
+            agToken: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
+            stakeToken: '0x0022228a2cc5E7eF0274A7Baa600d44da5aB5776',
+        },
+        [constants_1.Network.OPTIMISM]: {
+            agToken: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
+            stakeToken: '0x0022228a2cc5E7eF0274A7Baa600d44da5aB5776',
+        },
+        [constants_1.Network.POLYGON]: {
+            agToken: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
+            stakeToken: '0x0022228a2cc5E7eF0274A7Baa600d44da5aB5776',
+        },
+        [constants_1.Network.BASE]: {
+            agToken: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
+            stakeToken: '0x0022228a2cc5E7eF0274A7Baa600d44da5aB5776',
+        },
+        [constants_1.Network.BSC]: {
+            agToken: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
+            stakeToken: '0x0022228a2cc5E7eF0274A7Baa600d44da5aB5776',
+        },
+    },
+    // EURA <-> stEUR
+    AngleStakedStableEUR: {
+        [constants_1.Network.ARBITRUM]: {
+            agToken: '0xfa5ed56a203466cbbc2430a43c66b9d8723528e7',
+            stakeToken: '0x004626A008B1aCdC4c74ab51644093b155e59A23',
+        },
+        [constants_1.Network.MAINNET]: {
+            agToken: '0x1a7e4e63778B4f12a199C062f3eFdD288afCBce8',
+            stakeToken: '0x004626A008B1aCdC4c74ab51644093b155e59A23',
+        },
+        [constants_1.Network.OPTIMISM]: {
+            agToken: '0x9485aca5bbbe1667ad97c7fe7c4531a624c8b1ed',
+            stakeToken: '0x004626A008B1aCdC4c74ab51644093b155e59A23',
+        },
+        [constants_1.Network.POLYGON]: {
+            agToken: '0xe0b52e49357fd4daf2c15e02058dce6bc0057db4',
+            stakeToken: '0x004626A008B1aCdC4c74ab51644093b155e59A23',
+        },
+    },
+};
+exports.Adapters = {
+    [constants_1.Network.ARBITRUM]: {
+        [constants_1.SwapSide.SELL]: [
+            {
+                name: 'ArbitrumAdapter03',
+                index: 1,
+            },
+        ],
+        [constants_1.SwapSide.BUY]: [
+            {
+                name: 'ArbitrumBuyAdapter',
+                index: 10,
+            },
+        ],
+    },
+    [constants_1.Network.MAINNET]: {
+        [constants_1.SwapSide.SELL]: [
+            {
+                name: 'Adapter06',
+                index: 1,
+            },
+        ],
+        [constants_1.SwapSide.BUY]: [
+            {
+                name: 'BuyAdapter02',
+                index: 4,
+            },
+        ],
+    },
+    [constants_1.Network.OPTIMISM]: {
+        [constants_1.SwapSide.SELL]: [
+            {
+                name: 'OptimismAdapter02',
+                index: 1,
+            },
+        ],
+        [constants_1.SwapSide.BUY]: [
+            {
+                name: 'OptimismBuyAdapter',
+                index: 6,
+            },
+        ],
+    },
+    [constants_1.Network.BASE]: {
+        [constants_1.SwapSide.SELL]: [
+            {
+                name: 'BaseAdapter01',
+                index: 11,
+            },
+        ],
+        [constants_1.SwapSide.BUY]: [
+            {
+                name: 'BaseBuyAdapter',
+                index: 7,
+            },
+        ],
+    },
+    [constants_1.Network.POLYGON]: {
+        [constants_1.SwapSide.SELL]: [
+            {
+                name: 'PolygonAdapter02',
+                index: 10,
+            },
+        ],
+        [constants_1.SwapSide.BUY]: [
+            {
+                name: 'PolygonBuyAdapter',
+                index: 9,
+            },
+        ],
+    },
+    [constants_1.Network.BSC]: {
+        [constants_1.SwapSide.SELL]: [
+            {
+                name: 'BscAdapter02',
+                index: 10,
+            },
+        ],
+        [constants_1.SwapSide.BUY]: [
+            {
+                name: 'BscBuyAdapter',
+                index: 8,
+            },
+        ],
+    },
+};
+//# sourceMappingURL=config.js.map

package/build/dex/angle-staked-stable/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/dex/angle-staked-stable/config.ts"],"names":[],"mappings":"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"}

package/build/dex/angle-staked-stable/types.d.ts

@@ -0,0 +1,15 @@
+import { Address } from '../../types';
+export declare type PoolState = {
+    totalAssets: bigint;
+    totalSupply: bigint;
+    lastUpdate: bigint;
+    rate: bigint;
+    paused: boolean;
+};
+export declare type AngleStakedStableData = {
+    exchange: Address;
+};
+export declare type DexParams = {
+    agToken: Address;
+    stakeToken: Address;
+};

package/build/dex/angle-staked-stable/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/dex/angle-staked-stable/types.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,415 @@
+"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