@paraswap/dex-lib 4.1.20 → 4.1.21

package/src/dex/angle-transmuter/angle-transmuter.ts

@@ -1,407 +0,0 @@
-import { AsyncOrSync } from 'ts-essentials';
-import {
-  Token,
-  Address,
-  ExchangePrices,
-  PoolPrices,
-  AdapterExchangeParam,
-  PoolLiquidity,
-  Logger,
-  NumberAsString,
-  DexExchangeParam,
-} from '../../types';
-import { SwapSide, Network } from '../../constants';
-import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { getDexKeysWithNetwork } from '../../utils';
-import { Context, IDex } from '../../dex/idex';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { AngleTransmuterData, DexParams } from './types';
-import { SimpleExchange } from '../simple-exchange';
-import { AngleTransmuterConfig, Adapters } from './config';
-import { AngleTransmuterEventPool } from './angle-transmuter-pool';
-import { Interface, formatUnits, parseUnits } from 'ethers/lib/utils';
-import { TransmuterSubscriber } from './transmuter';
-import ERC20ABI from '../../abi/erc20.json';
-import { extractReturnAmountPosition } from '../../executor/utils';
-
-const TransmuterGasCost = 350000;
-
-export class AngleTransmuter
-  extends SimpleExchange
-  implements IDex<AngleTransmuterData>
-{
-  protected eventPools: { [key: string]: AngleTransmuterEventPool } = {};
-  protected supportedTokensMap: {
-    [key: string]: { [address: string]: boolean };
-  } = {};
-  protected supportedTokens: { [key: string]: Token[] } = {};
-  protected transmuterUSDLiquidity: { [key: string]: number } = {};
-  stablecoinList: string[];
-
-  public static erc20Interface = new Interface(ERC20ABI);
-
-  readonly hasConstantPriceLargeAmounts = false;
-  readonly needWrapNative = true;
-
-  readonly isFeeOnTransferSupported = false;
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(AngleTransmuterConfig);
-
-  logger: Logger;
-
-  constructor(
-    readonly network: Network,
-    readonly dexKey: string,
-    readonly dexHelper: IDexHelper,
-    protected adapters = Adapters[network] || {},
-    protected params: DexParams = AngleTransmuterConfig[dexKey][network],
-  ) {
-    super(dexHelper, dexKey);
-    this.logger = dexHelper.getLogger(dexKey);
-    this.stablecoinList = Object.keys(params);
-    this.stablecoinList.forEach(stablecoin => {
-      this.supportedTokensMap[stablecoin] = {};
-      this.supportedTokens[stablecoin] = [];
-      this.transmuterUSDLiquidity[stablecoin] = 0;
-    });
-    this.stablecoinList.forEach(stablecoin => {
-      this.supportedTokensMap[stablecoin][
-        params[stablecoin as keyof DexParams]!.stablecoin.address.toLowerCase()
-      ] = true;
-    });
-  }
-
-  // Initialize pricing is called once in the start of
-  // pricing service. It is intended to setup the integration
-  // for pricing requests. It is optional for a DEX to
-  // implement this function
-  async initializePricing(blockNumber: number) {
-    for (const stablecoin of this.stablecoinList) {
-      const config = await AngleTransmuterEventPool.getConfig(
-        this.params[stablecoin as keyof DexParams]!,
-        blockNumber,
-        this.dexHelper.multiContract,
-      );
-      config.collaterals.forEach(
-        (token: Address) =>
-          (this.supportedTokensMap[stablecoin][token.toLowerCase()] = true),
-      );
-      this.eventPools[stablecoin] = new AngleTransmuterEventPool(
-        this.dexKey,
-        this.network,
-        this.dexHelper,
-        this.logger,
-        config,
-      );
-      await this.eventPools[stablecoin].initialize(blockNumber);
-    }
-  }
-
-  // Returns the list of contract adapters (name and index)
-  // for a buy/sell. Return null if there are no adapters.
-  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    return null;
-  }
-
-  // Returns list of pool identifiers that can be used
-  // for a given swap. poolIdentifiers must be unique
-  // across DEXes. It is recommended to use
-  // ${dexKey}_${poolAddress} as a poolIdentifier
-  async getPoolIdentifiers(
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    blockNumber: number,
-  ): Promise<string[]> {
-    const knownInfo = this._knownAddress(srcToken, destToken);
-    if (!knownInfo.known) return [];
-    return [`${this.dexKey}_${knownInfo.agToken!.toLowerCase()}`];
-  }
-
-  // Returns pool prices for amounts.
-  // If limitPools is defined only pools in limitPools
-  // should be used. If limitPools is undefined then
-  // any pools can be used.
-  async getPricesVolume(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    side: SwapSide,
-    blockNumber: number,
-    limitPools?: string[],
-  ): Promise<null | ExchangePrices<AngleTransmuterData>> {
-    const knownInfo = this._knownAddress(srcToken, destToken);
-    const pool = `${this.dexKey}_${knownInfo.agToken!.toLowerCase()}`;
-    if (
-      !knownInfo.known ||
-      (limitPools && limitPools.length > 0 && !limitPools.includes(pool))
-    )
-      return null;
-
-    const fiat = knownInfo.fiatName! as keyof DexParams;
-    const preProcessDecimals =
-      side === SwapSide.SELL ? srcToken.decimals : destToken.decimals;
-    const postProcessDecimals =
-      side === SwapSide.SELL ? destToken.decimals : srcToken.decimals;
-    const unitVolume = 1;
-    const amountsFloat = amounts.map(amount =>
-      Number.parseFloat(formatUnits(amount.toString(), preProcessDecimals)),
-    );
-
-    const prices = await this.eventPools[fiat]!.getAmountOut(
-      srcToken.address.toLowerCase(),
-      destToken.address.toLowerCase(),
-      side,
-      [unitVolume, ...amountsFloat],
-      blockNumber,
-    );
-
-    if (!prices) return null;
-
-    const pricesBigInt = prices.map(price =>
-      BigInt(
-        parseUnits(
-          price.toFixed(postProcessDecimals).toString(),
-          postProcessDecimals,
-        ).toString(),
-      ),
-    );
-
-    return [
-      {
-        prices: pricesBigInt.slice(1),
-        unit: pricesBigInt[0],
-        gasCost: TransmuterGasCost,
-        exchange: this.dexKey,
-        data: { exchange: this.params[fiat]!.transmuter },
-        poolAddresses: [this.params[fiat]!.transmuter],
-      },
-    ];
-  }
-
-  // Returns estimated gas cost of calldata for this DEX in multiSwap
-  getCalldataGasCost(
-    poolPrices: PoolPrices<AngleTransmuterData>,
-  ): number | number[] {
-    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
-  }
-
-  // Encode params required by the exchange adapter
-  // Used for multiSwap, buy & megaSwap
-  // Hint: abiCoder.encodeParameter() could be useful
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: AngleTransmuterData,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    const { exchange } = data;
-
-    // Encode here the payload for adapter
-    const payload = '';
-
-    return {
-      targetExchange: exchange,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  getDexParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: AngleTransmuterData,
-    side: SwapSide,
-    _: Context,
-    executorAddress: Address,
-  ): DexExchangeParam {
-    const { exchange } = data;
-
-    // Encode here the transaction arguments
-    const swapData =
-      TransmuterSubscriber.transmuterCrosschainInterface.encodeFunctionData(
-        side === SwapSide.SELL ? 'swapExactInput' : 'swapExactOutput',
-        [
-          side === SwapSide.SELL ? srcAmount : destAmount,
-          side === SwapSide.SELL ? destAmount : srcAmount,
-          srcToken,
-          destToken,
-          recipient,
-          0,
-        ],
-      );
-
-    return {
-      needWrapNative: this.needWrapNative,
-      dexFuncHasRecipient: true,
-      exchangeData: swapData,
-      targetExchange: exchange,
-      returnAmountPos:
-        side === SwapSide.SELL
-          ? extractReturnAmountPosition(
-              TransmuterSubscriber.transmuterCrosschainInterface,
-              'swapExactInput',
-              'amountOut',
-            )
-          : undefined,
-    };
-  }
-
-  async updatePoolState(): Promise<void> {
-    for (const stablecoin of this.stablecoinList) {
-      const fiat = stablecoin as keyof DexParams;
-      const paramFiat = this.params[fiat]!;
-
-      if (!this.supportedTokens.length) {
-        let tokenAddresses = await AngleTransmuterEventPool.getCollateralsList(
-          paramFiat.transmuter,
-          'latest',
-          this.dexHelper.multiContract,
-        );
-        tokenAddresses = tokenAddresses.concat([paramFiat.stablecoin.address]);
-
-        const decimalsCallData =
-          AngleTransmuter.erc20Interface.encodeFunctionData('decimals');
-        const tokenBalanceMultiCall = tokenAddresses.map(t => ({
-          target: t,
-          callData: decimalsCallData,
-        }));
-        const res = (
-          await this.dexHelper.multiContract.methods
-            .aggregate(tokenBalanceMultiCall)
-            .call()
-        ).returnData;
-
-        const tokenDecimals = res.map((r: any) =>
-          Number.parseInt(
-            AngleTransmuter.erc20Interface
-              .decodeFunctionResult('decimals', r)[0]
-              .toString(),
-          ),
-        );
-
-        this.supportedTokens[fiat] = tokenAddresses.map((t, i) => ({
-          address: t,
-          decimals: tokenDecimals[i],
-        }));
-      }
-
-      // Only work if there are no managers
-      const erc20BalanceCalldata =
-        AngleTransmuter.erc20Interface.encodeFunctionData('balanceOf', [
-          paramFiat.transmuter,
-        ]);
-      const tokenBalanceMultiCall = this.supportedTokens[fiat].map(t => ({
-        target: t.address,
-        callData: erc20BalanceCalldata,
-      }));
-      const res = (
-        await this.dexHelper.multiContract.methods
-          .aggregate(tokenBalanceMultiCall)
-          .call()
-      ).returnData;
-      const tokenBalances = res.map((r: any) =>
-        BigInt(
-          AngleTransmuter.erc20Interface
-            .decodeFunctionResult('balanceOf', r)[0]
-            .toString(),
-        ),
-      );
-
-      // TODO bC3M price not detected
-      const tokenBalancesUSD = await Promise.all(
-        this.supportedTokens[fiat].map((t, i) =>
-          this.dexHelper.getTokenUSDPrice(t, tokenBalances[i]),
-        ),
-      );
-      this.transmuterUSDLiquidity[fiat] = tokenBalancesUSD.reduce(
-        (sum: number, curr: number) => sum + curr,
-      );
-    }
-  }
-
-  // Returns list of top pools based on liquidity. Max
-  // limit number pools should be returned.
-  async getTopPoolsForToken(
-    tokenAddress: Address,
-    limit: number,
-  ): Promise<PoolLiquidity[]> {
-    const tokenAddressLower = tokenAddress.toLowerCase();
-    for (const stablecoin of this.stablecoinList) {
-      const fiat = stablecoin as keyof DexParams;
-      const paramFiat = this.params[fiat]!;
-      const stableCoinLowercase = paramFiat.stablecoin.address.toLowerCase();
-
-      // If not this stable let's check another one
-      if (
-        !this.supportedTokens[fiat].some(
-          t => t.address.toLowerCase() === tokenAddressLower,
-        )
-      )
-        continue;
-
-      const connectorTokens =
-        tokenAddressLower === stableCoinLowercase
-          ? this.supportedTokens[fiat].filter(
-              token => token.address.toLowerCase() !== stableCoinLowercase,
-            )
-          : [paramFiat.stablecoin];
-
-      return [
-        {
-          exchange: this.dexKey,
-          address: paramFiat.transmuter,
-          connectorTokens: connectorTokens.slice(0, limit),
-          // liquidity is potentially infinite if swapping for agXXX, otherwise at most reserves value
-          liquidityUSD:
-            tokenAddressLower === stableCoinLowercase
-              ? this.transmuterUSDLiquidity[fiat]
-              : 1e9,
-        },
-      ];
-    }
-    return [];
-  }
-
-  releaseResources(): AsyncOrSync<void> {
-    Object.values(this.eventPools).forEach(pool => pool.releaseResources());
-  }
-
-  _knownAddress(
-    srcToken: Token,
-    destToken: Token,
-  ): { known: boolean; agToken: string | null; fiatName: string | null } {
-    const srcAddress = this.dexHelper.config
-      .wrapETH(srcToken)
-      .address.toLowerCase();
-    const destAddress = this.dexHelper.config
-      .wrapETH(destToken)
-      .address.toLowerCase();
-
-    for (const stablecoin of this.stablecoinList) {
-      const fiat = stablecoin as keyof DexParams;
-      const paramFiat = this.params[fiat]!;
-      if (
-        srcAddress !== destAddress &&
-        this.supportedTokensMap[stablecoin][srcAddress] &&
-        this.supportedTokensMap[stablecoin][destAddress] &&
-        // check that at least one of the tokens is EURA
-        (srcAddress === paramFiat.stablecoin.address.toLowerCase() ||
-          destAddress === paramFiat.stablecoin.address.toLowerCase())
-      ) {
-        return {
-          known: true,
-          agToken: paramFiat.stablecoin.address.toLowerCase(),
-          fiatName: stablecoin,
-        };
-      }
-    }
-    return { known: false, agToken: null, fiatName: null };
-  }
-}

package/src/dex/angle-transmuter/backedOracle.ts

@@ -1,91 +0,0 @@
-import { DeepReadonly } from 'ts-essentials';
-import { PartialEventSubscriber } from '../../composed-event-subscriber';
-import {
-  Address,
-  BlockHeader,
-  Log,
-  Logger,
-  MultiCallInput,
-  MultiCallOutput,
-} from '../../types';
-import { Lens } from '../../lens';
-import { Interface } from '@ethersproject/abi';
-import ProxyABI from '../../abi/chainlink.json';
-import { ChainLinkState } from '../../lib/chainlink';
-
-export class BackedSubscriber<State> extends PartialEventSubscriber<
-  State,
-  ChainLinkState
-> {
-  static readonly proxyInterface = new Interface(ProxyABI);
-  static readonly ANSWER_UPDATED_TOPIC =
-    BackedSubscriber.proxyInterface.getEventTopic('AnswerUpdated');
-
-  constructor(
-    private proxy: Address,
-    private aggregator: Address,
-    lens: Lens<DeepReadonly<State>, DeepReadonly<ChainLinkState>>,
-    logger: Logger,
-  ) {
-    super([aggregator], lens, logger);
-  }
-
-  static getReadDecimal(proxy: Address): MultiCallInput {
-    return {
-      target: proxy,
-      callData: BackedSubscriber.proxyInterface.encodeFunctionData('decimals'),
-    };
-  }
-
-  static readDecimals(multicallOutput: MultiCallOutput): Address {
-    return BackedSubscriber.proxyInterface.decodeFunctionResult(
-      'decimals',
-      multicallOutput,
-    )[0];
-  }
-
-  public processLog(
-    state: DeepReadonly<ChainLinkState>,
-    log: Readonly<Log>,
-    blockHeader: Readonly<BlockHeader>,
-  ): DeepReadonly<ChainLinkState> | null {
-    if (log.topics[0] !== BackedSubscriber.ANSWER_UPDATED_TOPIC) return null; // Ignore other events
-    const decoded = BackedSubscriber.proxyInterface.decodeEventLog(
-      'AnswerUpdated',
-      log.data,
-      log.topics,
-    );
-    return {
-      answer: BigInt(decoded.current.toString()),
-      timestamp: BigInt(decoded.updatedAt.toString()),
-    };
-  }
-
-  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
-    return [
-      {
-        target: this.proxy,
-        callData:
-          BackedSubscriber.proxyInterface.encodeFunctionData('latestRoundData'),
-      },
-    ];
-  }
-
-  public generateState(
-    multicallOutputs: MultiCallOutput[],
-    blockNumber?: number | 'latest',
-  ): DeepReadonly<ChainLinkState> {
-    const decoded = BackedSubscriber.proxyInterface.decodeFunctionResult(
-      'latestRoundData',
-      multicallOutputs[0],
-    );
-    return {
-      answer: BigInt(decoded.answer.toString()),
-      timestamp: BigInt(decoded.updatedAt.toString()),
-    };
-  }
-
-  public getLatestRoundData(state: DeepReadonly<State>): bigint {
-    return this.lens.get()(state).answer;
-  }
-}

package/src/dex/angle-transmuter/config.ts

@@ -1,50 +0,0 @@
-import { DexParams } from './types';
-import { DexConfigMap, AdapterMappings } from '../../types';
-import { Network, SwapSide } from '../../constants';
-
-export const AngleTransmuterConfig: DexConfigMap<DexParams> = {
-  AngleTransmuter: {
-    [Network.MAINNET]: {
-      EUR: {
-        stablecoin: {
-          address: '0x1a7e4e63778B4f12a199C062f3eFdD288afCBce8',
-          decimals: 18,
-        },
-        transmuter: '0x00253582b2a3FE112feEC532221d9708c64cEFAb',
-        pyth: '0x4305FB66699C3B2702D4d05CF36551390A4c69C6',
-      },
-      USD: {
-        stablecoin: {
-          address: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
-          decimals: 18,
-        },
-        transmuter: '0x222222fD79264BBE280b4986F6FEfBC3524d0137',
-        pyth: '0x4305FB66699C3B2702D4d05CF36551390A4c69C6',
-      },
-    },
-    [Network.ARBITRUM]: {
-      USD: {
-        stablecoin: {
-          address: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
-          decimals: 18,
-        },
-        transmuter: '0xD253b62108d1831aEd298Fc2434A5A8e4E418053',
-        pyth: '0xff1a0f4744e8582DF1aE09D5611b887B6a12925C',
-      },
-    },
-    [Network.BASE]: {
-      USD: {
-        stablecoin: {
-          address: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
-          decimals: 18,
-        },
-        transmuter: '0x222222880e079445Df703c0604706E71a538Fd4f',
-        pyth: '0x8250f4aF4B972684F7b336503E2D6dFeDeB1487a',
-      },
-    },
-  },
-};
-
-export const Adapters: Record<number, AdapterMappings> = {
-  [Network.MAINNET]: { [SwapSide.SELL]: [{ name: '', index: 0 }] },
-};

package/src/dex/angle-transmuter/constants.ts

@@ -1,138 +0,0 @@
-import { ethers } from 'ethers';
-import { bigIntify } from '../../utils';
-import { ChainlinkConfig, MorphoConfig, PoolConfig, PythConfig } from './types';
-
-export const CBETH = '0xBe9895146f7AF43049ca1c1AE358B0541Ea49704';
-export const RETH = '0xae78736Cd615f374D3085123A210448E74Fc6393';
-export const STETH = '0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84';
-export const SFRXETH = '0xac3E018457B222d93114458476f3E3416Abbe38F';
-
-export const configEUR: PoolConfig = {
-  stablecoin: {
-    address: '0x1a7e4e63778B4f12a199C062f3eFdD288afCBce8',
-    decimals: 18,
-  },
-  transmuter: '0x00253582b2a3FE112feEC532221d9708c64cEFAb',
-  collaterals: [
-    '0x3f95AA88dDbB7D9D484aa3D482bf0a80009c52c9',
-    '0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c',
-    '0x2F123cF3F37CE3328CC9B5b8415f9EC5109b45e7',
-  ],
-  oracles: {
-    chainlink: {},
-    backed: {
-      '0x83Ec02059F686E747392A22ddfED7833bA0d7cE3': {
-        proxy: '0x83Ec02059F686E747392A22ddfED7833bA0d7cE3',
-        aggregator: '0x83Ec02059F686E747392A22ddfED7833bA0d7cE3',
-        decimals: 8,
-      },
-      '0x475855DAe09af1e3f2d380d766b9E630926ad3CE': {
-        proxy: '0x475855DAe09af1e3f2d380d766b9E630926ad3CE',
-        aggregator: '0x475855DAe09af1e3f2d380d766b9E630926ad3CE',
-        decimals: 8,
-      },
-    },
-    redstone: {
-      '0x6E27A25999B3C665E44D903B2139F5a4Be2B6C26': {
-        proxy: '0x6E27A25999B3C665E44D903B2139F5a4Be2B6C26',
-        aggregator: '0x5BeEFeFE23aecccC77d164AB8E9Ff74e056588f1',
-        decimals: 8,
-      },
-    },
-    morpho: {},
-    pyth: {
-      proxy: '0x4305FB66699C3B2702D4d05CF36551390A4c69C6',
-      ids: [
-        '0x76fa85158bf14ede77087fe3ae472f66213f6ea2f5b411cb2de472794990fa5c',
-        '0xa995d00bb36a63cef7fd2c287dc105fc8f3d93779f062f09551b0af3e81ec30b',
-      ],
-    },
-  },
-};
-
-export const configUSD: PoolConfig = {
-  stablecoin: {
-    address: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
-    decimals: 18,
-  },
-  transmuter: '0x222222fD79264BBE280b4986F6FEfBC3524d0137',
-  collaterals: [
-    '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
-    '0xCA30c93B02514f86d5C86a6e375E3A330B435Fb5',
-    '0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB',
-  ],
-  oracles: {
-    backed: {} as ChainlinkConfig,
-    chainlink: {
-      '0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6': {
-        proxy: '0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6',
-        aggregator: '0x789190466E21a8b78b8027866CBBDc151542A26C',
-        decimals: 8,
-      },
-      '0x32d1463EB53b73C095625719Afa544D5426354cB': {
-        proxy: '0x32d1463EB53b73C095625719Afa544D5426354cB',
-        aggregator: '0x5EE6Ee50c1cB3E8Da20eE83D57818184387433e8',
-        decimals: 8,
-      },
-    },
-    redstone: {} as ChainlinkConfig,
-    morpho: {
-      '0x025106374196586E8BC91eE8818dD7B0Efd2B78B': {
-        baseVault: '0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB',
-        baseVaultConversion: bigIntify('1000000000000000000'),
-        quoteVault: ethers.constants.AddressZero,
-        quoteVaultConversion: bigIntify('1'),
-        baseFeed1: '0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6',
-        baseFeed2: ethers.constants.AddressZero,
-        quoteFeed1: ethers.constants.AddressZero,
-        quoteFeed2: ethers.constants.AddressZero,
-        scaleFactor: bigIntify('1000000000000000000'),
-      },
-    },
-    pyth: {} as PythConfig,
-  },
-};
-
-export const configUSDBase: PoolConfig = {
-  stablecoin: {
-    address: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
-    decimals: 18,
-  },
-  transmuter: '0x222222880e079445Df703c0604706E71a538Fd4f',
-  collaterals: ['0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'],
-  oracles: {
-    backed: {} as ChainlinkConfig,
-    chainlink: {
-      '0x7e860098F58bBFC8648a4311b374B1D669a2bc6B': {
-        proxy: '0x7e860098F58bBFC8648a4311b374B1D669a2bc6B',
-        aggregator: '0x0Ee7145e1370653533e2F2E824424bE2AA95A4Aa',
-        decimals: 8,
-      },
-    },
-    redstone: {} as ChainlinkConfig,
-    morpho: {} as MorphoConfig,
-    pyth: {} as PythConfig,
-  },
-};
-
-export const configUSDArbitrum: PoolConfig = {
-  stablecoin: {
-    address: '0x0000206329b97DB379d5E1Bf586BbDB969C63274',
-    decimals: 18,
-  },
-  transmuter: '0xD253b62108d1831aEd298Fc2434A5A8e4E418053',
-  collaterals: ['0xaf88d065e77c8cC2239327C5EDb3A432268e5831'],
-  oracles: {
-    backed: {} as ChainlinkConfig,
-    chainlink: {
-      '0x50834F3163758fcC1Df9973b6e91f0F0F0434aD3': {
-        proxy: '0x50834F3163758fcC1Df9973b6e91f0F0F0434aD3',
-        aggregator: '0x2946220288DbBF77dF0030fCecc2a8348CbBE32C',
-        decimals: 8,
-      },
-    },
-    redstone: {} as ChainlinkConfig,
-    morpho: {} as MorphoConfig,
-    pyth: {} as PythConfig,
-  },
-};