@paraswap/dex-lib 4.1.19-pools.0 → 4.1.19-pools.2

package/src/dex/aave-gsm/aave-gsm-pool.ts

@@ -1,225 +0,0 @@
-import { Interface } from '@ethersproject/abi';
-import { DeepReadonly } from 'ts-essentials';
-import { Log, Logger } from '../../types';
-import { catchParseLogError } from '../../utils';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { PoolState } from './types';
-import GSM_ABI from '../../abi/aave-gsm/Aave_GSM.json';
-import FEE_STRATEGY_ABI from '../../abi/aave-gsm/IFeeStrategy.json';
-import {
-  addressDecode,
-  booleanDecode,
-  uint256ToBigInt,
-} from '../../lib/decoders';
-
-export class AaveGsmEventPool extends StatefulEventSubscriber<PoolState> {
-  handlers: {
-    [event: string]: (
-      event: any,
-      state: DeepReadonly<PoolState>,
-      log: Readonly<Log>,
-    ) => Promise<DeepReadonly<PoolState> | null>;
-  } = {};
-
-  logDecoder: (log: Log) => any;
-
-  addressesSubscribed: string[];
-
-  constructor(
-    readonly gsm: string,
-    readonly parentName: string,
-    protected network: number,
-    protected dexHelper: IDexHelper,
-    logger: Logger,
-    protected aaveGsmIface = new Interface(GSM_ABI),
-    protected feeStrategyIface = new Interface(FEE_STRATEGY_ABI),
-    protected PERCENT_FACTOR = 10_000n,
-  ) {
-    super(parentName, `${parentName}_${gsm}`, dexHelper, logger);
-
-    this.logDecoder = (log: Log) => this.aaveGsmIface.parseLog(log);
-    this.addressesSubscribed = [gsm];
-
-    // Add handlers
-    this.handlers['FeeStrategyUpdated'] =
-      this.handleFeeStrategyUpdated.bind(this);
-
-    this.handlers['SwapFreeze'] = this.handleSwapFreeze.bind(this);
-    this.handlers['Seized'] = this.handleSeized.bind(this);
-    this.handlers['ExposureCapUpdated'] =
-      this.handleExposureCapUpdated.bind(this);
-    this.handlers['BuyAsset'] = this.handleBuyAsset.bind(this);
-    this.handlers['SellAsset'] = this.handleSellAsset.bind(this);
-  }
-
-  getIdentifier(): string {
-    return `${this.parentName}_${this.gsm}`;
-  }
-
-  protected async processLog(
-    state: DeepReadonly<PoolState>,
-    log: Readonly<Log>,
-  ): Promise<DeepReadonly<PoolState> | null> {
-    try {
-      const event = this.logDecoder(log);
-      if (event.name in this.handlers) {
-        return await this.handlers[event.name](event, state, log);
-      }
-    } catch (e) {
-      catchParseLogError(e, this.logger);
-    }
-
-    return null;
-  }
-
-  async getOnChainState(
-    address: string,
-    blockNumber: number | string = 'latest',
-  ): Promise<PoolState> {
-    const callData = [
-      {
-        target: address,
-        callData: this.feeStrategyIface.encodeFunctionData('getBuyFee', [
-          this.PERCENT_FACTOR,
-        ]),
-        decodeFunction: uint256ToBigInt,
-      },
-      {
-        target: address,
-        callData: this.feeStrategyIface.encodeFunctionData('getSellFee', [
-          this.PERCENT_FACTOR,
-        ]),
-        decodeFunction: uint256ToBigInt,
-      },
-      {
-        target: this.gsm,
-        callData: this.aaveGsmIface.encodeFunctionData(
-          'getAvailableLiquidity',
-          [],
-        ),
-        decodeFunction: uint256ToBigInt,
-      },
-      {
-        target: this.gsm,
-        callData: this.aaveGsmIface.encodeFunctionData('getIsFrozen', []),
-        decodeFunction: booleanDecode,
-      },
-      {
-        target: this.gsm,
-        callData: this.aaveGsmIface.encodeFunctionData('getIsSeized', []),
-        decodeFunction: booleanDecode,
-      },
-      {
-        target: this.gsm,
-        callData: this.aaveGsmIface.encodeFunctionData('getExposureCap', []),
-        decodeFunction: uint256ToBigInt,
-      },
-    ];
-
-    const results = await this.dexHelper.multiWrapper.tryAggregate<
-      bigint | boolean
-    >(true, callData, blockNumber);
-
-    return {
-      buyFee: results[0].returnData as bigint,
-      sellFee: results[1].returnData as bigint,
-      underlyingLiquidity: results[2].returnData as bigint,
-      isFrozen: results[3].returnData as boolean,
-      isSeized: results[4].returnData as boolean,
-      exposureCap: results[5].returnData as bigint,
-    };
-  }
-
-  async generateState(
-    blockNumber: number | string = 'latest',
-  ): Promise<DeepReadonly<PoolState>> {
-    const callData = [
-      {
-        target: this.gsm,
-        callData: this.aaveGsmIface.encodeFunctionData('getFeeStrategy', []),
-        decodeFunction: addressDecode,
-      },
-    ];
-
-    const feeStrategy = await this.dexHelper.multiWrapper.tryAggregate<string>(
-      true,
-      callData,
-      blockNumber,
-    );
-
-    const result = await this.getOnChainState(
-      feeStrategy[0].returnData,
-      blockNumber,
-    );
-
-    return result;
-  }
-
-  async handleFeeStrategyUpdated(
-    event: any,
-    state: DeepReadonly<PoolState>,
-    log: Readonly<Log>,
-  ): Promise<DeepReadonly<PoolState> | null> {
-    return await this.getOnChainState(event.args.newFeeStrategy);
-  }
-
-  async handleSwapFreeze(
-    event: any,
-    state: DeepReadonly<PoolState>,
-    log: Readonly<Log>,
-  ): Promise<DeepReadonly<PoolState> | null> {
-    return {
-      ...state,
-      isFrozen: event.args.enabled,
-    };
-  }
-
-  async handleSeized(
-    event: any,
-    state: DeepReadonly<PoolState>,
-    log: Readonly<Log>,
-  ): Promise<DeepReadonly<PoolState> | null> {
-    return {
-      ...state,
-      isSeized: true,
-      exposureCap: BigInt(0),
-      underlyingLiquidity: BigInt(0),
-    };
-  }
-
-  async handleExposureCapUpdated(
-    event: any,
-    state: DeepReadonly<PoolState>,
-    log: Readonly<Log>,
-  ): Promise<DeepReadonly<PoolState> | null> {
-    return {
-      ...state,
-      exposureCap: BigInt(event.args.newExposureCap),
-    };
-  }
-
-  async handleBuyAsset(
-    event: any,
-    state: DeepReadonly<PoolState>,
-    log: Readonly<Log>,
-  ): Promise<DeepReadonly<PoolState> | null> {
-    return {
-      ...state,
-      underlyingLiquidity:
-        state.underlyingLiquidity - BigInt(event.args.underlyingAmount),
-    };
-  }
-
-  async handleSellAsset(
-    event: any,
-    state: DeepReadonly<PoolState>,
-    log: Readonly<Log>,
-  ): Promise<DeepReadonly<PoolState> | null> {
-    return {
-      ...state,
-      underlyingLiquidity:
-        state.underlyingLiquidity + BigInt(event.args.underlyingAmount),
-    };
-  }
-}

package/src/dex/aave-gsm/aave-gsm.ts

@@ -1,431 +0,0 @@
-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 { IDex } from '../../dex/idex';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { AaveGsmData, DexParams, PoolState } from './types';
-import { SimpleExchange } from '../simple-exchange';
-import { AaveGsmConfig } from './config';
-
-import GSM_ABI from '../../abi/aave-gsm/Aave_GSM.json';
-import { Interface } from '@ethersproject/abi';
-import { formatUnits, parseUnits } from 'ethers/lib/utils';
-import { AaveGsmEventPool } from './aave-gsm-pool';
-import { MMath } from '../maverick-v1/maverick-math/maverick-basic-math';
-import {
-  RETURN_AMOUNT_POS_0,
-  RETURN_AMOUNT_POS_32,
-} from '../../executor/constants';
-
-export class AaveGsm extends SimpleExchange implements IDex<AaveGsmData> {
-  static readonly gsmInterface = new Interface(GSM_ABI);
-  protected eventPools: Record<string, AaveGsmEventPool>;
-
-  protected config: DexParams;
-
-  readonly hasConstantPriceLargeAmounts = false;
-  readonly needWrapNative = false;
-
-  readonly isFeeOnTransferSupported = false;
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(AaveGsmConfig);
-
-  logger: Logger;
-
-  constructor(
-    readonly network: Network,
-    readonly dexKey: string,
-    readonly dexHelper: IDexHelper,
-  ) {
-    super(dexHelper, dexKey);
-    const config = AaveGsmConfig[dexKey][network];
-    this.config = {
-      GSM_USDT: config.GSM_USDT.toLowerCase(),
-      GSM_USDC: config.GSM_USDC.toLowerCase(),
-      USDT: config.USDT.toLowerCase(),
-      USDC: config.USDC.toLowerCase(),
-      GHO: config.GHO.toLowerCase(),
-    };
-
-    this.logger = dexHelper.getLogger(dexKey);
-
-    this.eventPools = {
-      [this.config.GSM_USDT]: new AaveGsmEventPool(
-        this.config.GSM_USDT,
-        this.dexKey,
-        this.network,
-        this.dexHelper,
-        this.logger,
-      ),
-      [this.config.GSM_USDC]: new AaveGsmEventPool(
-        this.config.GSM_USDC,
-        this.dexKey,
-        this.network,
-        this.dexHelper,
-        this.logger,
-      ),
-    };
-  }
-
-  async initializePoolPricing(pool: AaveGsmEventPool, blockNumber: number) {
-    const state = await pool.generateState(blockNumber);
-
-    pool.initialize(blockNumber, {
-      state,
-    });
-  }
-
-  async initializePricing(blockNumber: number) {
-    await this.initializePoolPricing(
-      this.eventPools[this.config.GSM_USDT],
-      blockNumber,
-    );
-    await this.initializePoolPricing(
-      this.eventPools[this.config.GSM_USDC],
-      blockNumber,
-    );
-  }
-
-  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    return null;
-  }
-
-  async getPoolIdentifiers(
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    blockNumber: number,
-  ): Promise<string[]> {
-    const srcTokenAddress = srcToken.address.toLowerCase();
-    const destTokenAddress = destToken.address.toLowerCase();
-
-    if (
-      (srcTokenAddress === this.config.GHO &&
-        destTokenAddress === this.config.USDT) ||
-      (srcTokenAddress === this.config.USDT &&
-        destTokenAddress === this.config.GHO)
-    ) {
-      return [`${this.dexKey}_${this.config.GSM_USDT}`];
-    } else if (
-      (srcTokenAddress === this.config.GHO &&
-        destTokenAddress === this.config.USDC) ||
-      (srcTokenAddress === this.config.USDC &&
-        destTokenAddress === this.config.GHO)
-    ) {
-      return [`${this.dexKey}_${this.config.GSM_USDC}`];
-    } else {
-      return [];
-    }
-  }
-
-  async getPoolState(gsm: string, blockNumber?: number): Promise<PoolState> {
-    if (!blockNumber) {
-      return this.eventPools[gsm].getStaleState()!;
-    }
-    const eventState = this.eventPools[gsm].getState(blockNumber);
-    if (eventState) return eventState;
-    const onChainState = await this.eventPools[gsm].generateState(blockNumber);
-    this.eventPools[gsm].setState(onChainState, blockNumber);
-    return onChainState;
-  }
-
-  canBuyAsset(assetAmount: bigint, state: PoolState) {
-    return assetAmount > 0n && state.underlyingLiquidity >= assetAmount;
-  }
-
-  canSellAsset(assetAmount: bigint, state: PoolState) {
-    return (
-      assetAmount > 0n &&
-      state.underlyingLiquidity + assetAmount <= state.exposureCap
-    );
-  }
-
-  getGhoAmountForBuyAsset(assetAmount: bigint, state: PoolState) {
-    if (!this.canBuyAsset(assetAmount, state)) {
-      return 0n;
-    }
-
-    const grossAmount = assetAmount * 1_000_000_000_000n; // 18 - 6 = 12 (decimals)
-    const fee = MMath.mulDiv(grossAmount, state.buyFee, 10_000n, true);
-
-    const result = grossAmount + fee;
-
-    return result;
-  }
-
-  getAssetAmountForBuyAsset(ghoAmount: bigint, state: PoolState) {
-    const grossAmount = (ghoAmount * 10_000n) / (10_000n + state.buyFee);
-
-    const result = grossAmount / 1_000_000_000_000n; // 18 - 6 = 12 (decimals)
-
-    if (this.canBuyAsset(result, state)) {
-      return result;
-    }
-    return 0n;
-  }
-
-  getGhoAmountForSellAsset(assetAmount: bigint, state: PoolState) {
-    if (!this.canSellAsset(assetAmount, state)) {
-      return 0n;
-    }
-
-    const grossAmount = assetAmount * 1_000_000_000_000n; // 18 - 6 = 12 (decimals)
-    const fee = MMath.mulDiv(grossAmount, state.sellFee, 10_000n, true);
-
-    return grossAmount - fee;
-  }
-
-  getAssetAmountForSellAsset(ghoAmount: bigint, state: PoolState) {
-    const grossAmount = MMath.mulDiv(
-      ghoAmount,
-      10_000n,
-      10_000n - state.sellFee,
-      true,
-    );
-
-    const result = MMath.mulDiv(grossAmount, 1n, 1_000_000_000_000n, true); // 18 - 6 = 12 (decimals)
-
-    if (this.canSellAsset(result, state)) {
-      return result;
-    }
-    return 0n;
-  }
-
-  async getPricesVolume(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    side: SwapSide,
-    blockNumber: number,
-    limitPools?: string[],
-  ): Promise<null | ExchangePrices<AaveGsmData>> {
-    const srcTokenAddress = srcToken.address.toLowerCase();
-    const destTokenAddress = destToken.address.toLowerCase();
-
-    if (
-      !(
-        (srcTokenAddress === this.config.GHO &&
-          (destTokenAddress === this.config.USDC ||
-            destTokenAddress === this.config.USDT)) ||
-        (destTokenAddress === this.config.GHO &&
-          (srcTokenAddress === this.config.USDC ||
-            srcTokenAddress === this.config.USDT))
-      )
-    ) {
-      return null;
-    }
-
-    let endpoint: Function;
-    let target: string;
-    let gas: number;
-
-    if (
-      srcTokenAddress === this.config.USDT ||
-      destTokenAddress === this.config.USDT
-    ) {
-      target = this.config.GSM_USDT;
-    } else {
-      target = this.config.GSM_USDC;
-    }
-
-    if (srcTokenAddress === this.config.GHO && side === SwapSide.BUY) {
-      // amount = destAmount = assetAmount
-      endpoint = this.getGhoAmountForBuyAsset.bind(this);
-      gas = 80_000;
-    } else if (srcTokenAddress === this.config.GHO && side === SwapSide.SELL) {
-      // amount = srcAmount = ghoAmount
-      endpoint = this.getAssetAmountForBuyAsset.bind(this);
-      gas = 80_000;
-    } else if (destTokenAddress === this.config.GHO && side === SwapSide.SELL) {
-      // amount = srcAmount = assetAmount
-      endpoint = this.getGhoAmountForSellAsset.bind(this);
-      gas = 70_000;
-    } else {
-      // amount = destAmount = ghoAmount
-      endpoint = this.getAssetAmountForSellAsset.bind(this);
-      gas = 70_000;
-    }
-
-    const unit = parseUnits(
-      '1',
-      side === SwapSide.SELL ? srcToken.decimals : destToken.decimals,
-    ).toBigInt();
-
-    const poolState = await this.getPoolState(target, blockNumber);
-
-    if (poolState.isFrozen || poolState.isSeized) {
-      return null;
-    }
-
-    return [
-      {
-        unit: endpoint(unit, poolState),
-        prices: amounts.map(amount => endpoint(amount, poolState)),
-        data: {
-          exchange: this.dexKey,
-        },
-        poolAddresses: [target],
-        exchange: this.dexKey,
-        gasCost: gas,
-        poolIdentifier: `${this.dexKey}_${target}`,
-      },
-    ];
-  }
-
-  getCalldataGasCost(poolPrices: PoolPrices<AaveGsmData>): number | number[] {
-    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
-  }
-
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: AaveGsmData,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    const { exchange } = data;
-
-    const payload = '';
-
-    return {
-      targetExchange: exchange,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  async getDexParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    recipient: Address,
-    data: AaveGsmData,
-    side: SwapSide,
-  ): Promise<DexExchangeParam> {
-    const isSrcGho = srcToken.toLowerCase() === this.config.GHO;
-    const swapFunction = isSrcGho ? 'buyAsset' : 'sellAsset';
-    const ghoAmount = isSrcGho ? srcAmount : destAmount;
-    let assetAmount = isSrcGho ? destAmount : srcAmount;
-    const targetExchange =
-      srcToken.toLowerCase() === this.config.USDT ||
-      destToken.toLowerCase() === this.config.USDT
-        ? this.config.GSM_USDT
-        : this.config.GSM_USDC;
-
-    if (BigInt(assetAmount) === 1n) {
-      const poolState = await this.getPoolState(targetExchange);
-      assetAmount = isSrcGho
-        ? this.getAssetAmountForBuyAsset(
-            BigInt(ghoAmount),
-            poolState,
-          ).toString()
-        : this.getAssetAmountForSellAsset(
-            BigInt(ghoAmount),
-            poolState,
-          ).toString();
-    }
-
-    const exchangeData = AaveGsm.gsmInterface.encodeFunctionData(swapFunction, [
-      assetAmount,
-      recipient,
-    ]);
-
-    return {
-      needWrapNative: this.needWrapNative,
-      dexFuncHasRecipient: true,
-      exchangeData,
-      targetExchange,
-      returnAmountPos:
-        side === SwapSide.SELL
-          ? isSrcGho
-            ? RETURN_AMOUNT_POS_0
-            : RETURN_AMOUNT_POS_32
-          : undefined,
-    };
-  }
-
-  async getTopPoolsForToken(
-    tokenAddress: Address,
-    limit: number,
-  ): Promise<PoolLiquidity[]> {
-    tokenAddress = tokenAddress.toLowerCase();
-
-    if (tokenAddress === this.config.GHO) {
-      const usdtState = this.eventPools[this.config.GSM_USDT].getStaleState();
-      const usdcState = this.eventPools[this.config.GSM_USDC].getStaleState();
-
-      return [
-        {
-          exchange: this.dexKey,
-          address: this.config.GSM_USDT,
-          connectorTokens: [
-            {
-              decimals: 6,
-              address: this.config.USDT,
-            },
-          ],
-          liquidityUSD: usdtState
-            ? +formatUnits(usdtState.underlyingLiquidity, 6)
-            : 1000000000,
-        },
-        {
-          exchange: this.dexKey,
-          address: this.config.GSM_USDC,
-          connectorTokens: [
-            {
-              decimals: 6,
-              address: this.config.USDC,
-            },
-          ],
-          liquidityUSD: usdcState
-            ? +formatUnits(usdcState.underlyingLiquidity, 6)
-            : 1000000000,
-        },
-      ];
-    } else if (tokenAddress === this.config.USDC) {
-      return [
-        {
-          exchange: this.dexKey,
-          address: this.config.GSM_USDC,
-          connectorTokens: [
-            {
-              decimals: 18,
-              address: this.config.GHO,
-            },
-          ],
-          liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
-        },
-      ];
-    } else if (tokenAddress === this.config.USDT) {
-      return [
-        {
-          exchange: this.dexKey,
-          address: this.config.GSM_USDT,
-          connectorTokens: [
-            {
-              decimals: 18,
-              address: this.config.GHO,
-            },
-          ],
-          liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
-        },
-      ];
-    } else {
-      return [];
-    }
-  }
-}

package/src/dex/aave-gsm/config.ts

@@ -1,16 +0,0 @@
-import { DexParams } from './types';
-import { DexConfigMap } from '../../types';
-import { Network } from '../../constants';
-import { AaveV3Ethereum, GhoEthereum } from '@bgd-labs/aave-address-book';
-
-export const AaveGsmConfig: DexConfigMap<DexParams> = {
-  AaveGsm: {
-    [Network.MAINNET]: {
-      GSM_USDT: GhoEthereum.GSM_USDT,
-      GSM_USDC: GhoEthereum.GSM_USDC,
-      USDT: AaveV3Ethereum.ASSETS.USDT.UNDERLYING,
-      USDC: AaveV3Ethereum.ASSETS.USDC.UNDERLYING,
-      GHO: AaveV3Ethereum.ASSETS.GHO.UNDERLYING,
-    },
-  },
-};

package/src/dex/aave-gsm/types.ts

@@ -1,24 +0,0 @@
-import { Address } from '../../types';
-
-export type PoolState = {
-  buyFee: bigint;
-  sellFee: bigint;
-  underlyingLiquidity: bigint;
-  isFrozen: boolean;
-  isSeized: boolean;
-  exposureCap: bigint;
-};
-
-export type AaveGsmData = {
-  // returned by the API that can be used for
-  // tx building. The data structure should be minimal.
-  exchange: Address;
-};
-
-export type DexParams = {
-  GSM_USDT: string;
-  GSM_USDC: string;
-  USDT: string;
-  USDC: string;
-  GHO: string;
-};