@paraswap/dex-lib 3.6.3 → 3.6.4-transmuter.2

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

@@ -0,0 +1,443 @@
+import { AsyncOrSync } from 'ts-essentials';
+import {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  SimpleExchangeParam,
+  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';
+
+const TransmuterGasCost = 0;
+
+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 this.adapters[side] ? this.adapters[side] : 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,
+      destToken.address,
+      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',
+    };
+  }
+
+  // Encode call data used by simpleSwap like routers
+  // Used for simpleSwap & simpleBuy
+  // Hint: this.buildSimpleParamWithoutWETHConversion
+  // could be useful
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: AngleTransmuterData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    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,
+          this.augustusAddress,
+          0, // TODO no deadline?
+        ],
+      );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      exchange,
+    );
+  }
+
+  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: undefined,
+    };
+  }
+
+  // This is called once before getTopPoolsForToken is
+  // called for multiple tokens. This can be helpful to
+  // update common state required for calculating
+  // getTopPoolsForToken. It is optional for a DEX
+  // to implement this
+  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[]> {
+    for (const stablecoin of this.stablecoinList) {
+      const fiat = stablecoin as keyof DexParams;
+      const paramFiat = this.params[fiat]!;
+
+      // If not this stable let's check another one
+      if (
+        !this.supportedTokens[fiat].some(
+          t => t.address.toLowerCase() === tokenAddress.toLowerCase(),
+        )
+      )
+        continue;
+
+      const connectorTokens =
+        tokenAddress === paramFiat.stablecoin.address
+          ? this.supportedTokens[fiat].filter(
+              token =>
+                token.address.toLowerCase() !==
+                paramFiat.stablecoin.address.toLowerCase(),
+            )
+          : [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:
+            tokenAddress === paramFiat.stablecoin.address
+              ? this.transmuterUSDLiquidity[fiat]
+              : 1e9,
+        },
+      ];
+    }
+    return [];
+  }
+
+  // This is optional function in case if your implementation has acquired any resources
+  // you need to release for graceful shutdown. For example, it may be any interval timer
+  releaseResources(): AsyncOrSync<void> {}
+
+  _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

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

@@ -0,0 +1,50 @@
+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 }] },
+};