@paraswap/dex-lib 3.8.30 → 3.8.32-aave-gsm

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

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

@@ -0,0 +1,436 @@
+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 updatePoolState(): Promise<void> {
+    const blockNumber = await this.dexHelper.web3Provider.eth.getBlockNumber();
+    await this.initializePricing(blockNumber);
+  }
+
+  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

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

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

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