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

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

@@ -76,7 +76,8 @@ describe('AaveGsm E2E', () => {
     const tokenBSymbol: string = 'USDT';
 
     const tokenAAmount: string = '1000000000000000000';
-    const tokenBAmount: string = '1000000';
+    const tokenBAmount: string = '47166262';
+    // const tokenBAmount: string = '47166263';
 
     testForNetwork(
       network,

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

@@ -38,6 +38,9 @@ describe('AaveGsm EventPool Mainnet', function () {
   const eventsToTest: Record<Address, EventMappings> = {
     [AaveGsmConfig[dexKey][network].GSM_USDT]: {
       FeeStrategyUpdated: [], // Hasn't been emitted yet
+      BuyAsset: [20634073],
+      SellAsset: [20641217, 20641520, 20641913],
+      ExposureCapUpdated: [], // Hasn't been emitted yet
     },
   };
 

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

@@ -47,6 +47,10 @@ export class AaveGsmEventPool extends StatefulEventSubscriber<PoolState> {
 
     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 {
@@ -106,6 +110,11 @@ export class AaveGsmEventPool extends StatefulEventSubscriber<PoolState> {
         callData: this.aaveGsmIface.encodeFunctionData('getIsSeized', []),
         decodeFunction: booleanDecode,
       },
+      {
+        target: this.gsm,
+        callData: this.aaveGsmIface.encodeFunctionData('getExposureCap', []),
+        decodeFunction: uint256ToBigInt,
+      },
     ];
 
     const results = await this.dexHelper.multiWrapper.tryAggregate<
@@ -118,6 +127,7 @@ export class AaveGsmEventPool extends StatefulEventSubscriber<PoolState> {
       underlyingLiquidity: results[2].returnData as bigint,
       isFrozen: results[3].returnData as boolean,
       isSeized: results[4].returnData as boolean,
+      exposureCap: results[5].returnData as bigint,
     };
   }
 
@@ -173,6 +183,43 @@ export class AaveGsmEventPool extends StatefulEventSubscriber<PoolState> {
     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,4 +1,3 @@
-import { AsyncOrSync } from 'ts-essentials';
 import {
   Token,
   Address,
@@ -147,25 +146,43 @@ export class AaveGsm extends SimpleExchange implements IDex<AaveGsmData> {
     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 (assetAmount === 0n) {
+    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);
 
-    return grossAmount + fee;
+    const result = grossAmount + fee;
+
+    return result;
   }
 
   getAssetAmountForBuyAsset(ghoAmount: bigint, state: PoolState) {
     const grossAmount = (ghoAmount * 10_000n) / (10_000n + state.buyFee);
 
-    return grossAmount / 1_000_000_000_000n; // 18 - 6 = 12 (decimals)
+    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 (assetAmount === 0n) {
+    if (!this.canSellAsset(assetAmount, state)) {
       return 0n;
     }
 
@@ -183,7 +200,12 @@ export class AaveGsm extends SimpleExchange implements IDex<AaveGsmData> {
       true,
     );
 
-    return MMath.mulDiv(grossAmount, 1n, 1_000_000_000_000n, true); // 18 - 6 = 12 (decimals)
+    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(
@@ -224,16 +246,20 @@ export class AaveGsm extends SimpleExchange implements IDex<AaveGsmData> {
     }
 
     if (srcTokenAddress === this.config.GHO && side === SwapSide.BUY) {
-      endpoint = this.getGhoAmountForBuyAsset;
+      // amount = destAmount = assetAmount
+      endpoint = this.getGhoAmountForBuyAsset.bind(this);
       gas = 80_000;
     } else if (srcTokenAddress === this.config.GHO && side === SwapSide.SELL) {
-      endpoint = this.getAssetAmountForBuyAsset;
+      // amount = srcAmount = ghoAmount
+      endpoint = this.getAssetAmountForBuyAsset.bind(this);
       gas = 80_000;
     } else if (destTokenAddress === this.config.GHO && side === SwapSide.SELL) {
-      endpoint = this.getGhoAmountForSellAsset;
+      // amount = srcAmount = assetAmount
+      endpoint = this.getGhoAmountForSellAsset.bind(this);
       gas = 70_000;
     } else {
-      endpoint = this.getAssetAmountForSellAsset;
+      // amount = destAmount = ghoAmount
+      endpoint = this.getAssetAmountForSellAsset.bind(this);
       gas = 70_000;
     }
 

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

@@ -6,6 +6,7 @@ export type PoolState = {
   underlyingLiquidity: bigint;
   isFrozen: boolean;
   isSeized: boolean;
+  exposureCap: bigint;
 };
 
 export type AaveGsmData = {

package/src/dex/index.ts

@@ -88,6 +88,7 @@ import { ConcentratorArusd } from './concentrator-arusd/concentrator-arusd';
 import { FxProtocolRusd } from './fx-protocol-rusd/fx-protocol-rusd';
 import { AaveGsm } from './aave-gsm/aave-gsm';
 import { LitePsm } from './lite-psm/lite-psm';
+import { StkGHO } from './stkgho/stkgho';
 
 const LegacyDexes = [
   CurveV2,
@@ -171,6 +172,7 @@ const Dexes = [
   FxProtocolRusd,
   AaveGsm,
   LitePsm,
+  StkGHO,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/stkgho/config.ts

@@ -0,0 +1,14 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+
+import { MiscEthereum } from '@bgd-labs/aave-address-book';
+
+export const StkGHOConfig: DexConfigMap<DexParams> = {
+  StkGHO: {
+    [Network.MAINNET]: {
+      stkGHO: '0x1a88Df1cFe15Af22B3c4c783D4e6F7F9e0C1885d',
+      GHO: MiscEthereum.GHO_TOKEN,
+    },
+  },
+};

package/src/dex/stkgho/stkgho-e2e.test.ts

@@ -0,0 +1,77 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('StkGHO E2E', () => {
+  const dexKey = 'StkGHO';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'GHO';
+    const tokenBSymbol: string = 'stkGHO';
+
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+});

package/src/dex/stkgho/stkgho-events.test.ts

@@ -0,0 +1,79 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { StkGHOEventPool } from './stkgho-pool';
+import { Network } from '../../constants';
+import { Address } from '../../types';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { PoolState } from './types';
+import { StkGHOConfig } from './config';
+
+jest.setTimeout(50 * 1000);
+
+async function fetchPoolState(
+  stkGHOPool: StkGHOEventPool,
+  blockNumber: number,
+  poolAddress: string,
+): Promise<PoolState> {
+  const eventState = stkGHOPool.getState(blockNumber);
+  if (eventState) return eventState;
+  const onChainState = await stkGHOPool.generateState(blockNumber);
+  stkGHOPool.setState(onChainState, blockNumber);
+  return onChainState;
+}
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, number[]>;
+
+describe('StkGHO EventPool Mainnet', function () {
+  const dexKey = 'StkGHO';
+  const network = Network.MAINNET;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  let stkGHOPool: StkGHOEventPool;
+
+  // poolAddress -> EventMappings
+  const eventsToTest: Record<Address, EventMappings> = {
+    [StkGHOConfig[dexKey][network].stkGHO]: {
+      ExchangeRateChanged: [], // haven't been emitted yet
+    },
+  };
+
+  beforeEach(async () => {
+    stkGHOPool = new StkGHOEventPool(
+      dexKey,
+      dexKey,
+      network,
+      dexHelper,
+      logger,
+    );
+  });
+
+  Object.entries(eventsToTest).forEach(
+    ([poolAddress, events]: [string, EventMappings]) => {
+      describe(`Events for ${poolAddress}`, () => {
+        Object.entries(events).forEach(
+          ([eventName, blockNumbers]: [string, number[]]) => {
+            describe(`${eventName}`, () => {
+              blockNumbers.forEach((blockNumber: number) => {
+                it(`State after ${blockNumber}`, async function () {
+                  await testEventSubscriber(
+                    stkGHOPool,
+                    stkGHOPool.addressesSubscribed,
+                    (_blockNumber: number) =>
+                      fetchPoolState(stkGHOPool, _blockNumber, poolAddress),
+                    blockNumber,
+                    `${dexKey}_${poolAddress}`,
+                    dexHelper.provider,
+                  );
+                });
+              });
+            });
+          },
+        );
+      });
+    },
+  );
+});

package/src/dex/stkgho/stkgho-integration.test.ts

@@ -0,0 +1,226 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Interface, Result } from '@ethersproject/abi';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { StkGHO } from './stkgho';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+import StkGHO_ABI from '../../abi/stkGHO.json';
+
+function getReaderCalldata(
+  exchangeAddress: string,
+  readerIface: Interface,
+  amounts: bigint[],
+  funcName: string,
+) {
+  return amounts.map(amount => ({
+    target: exchangeAddress,
+    callData: readerIface.encodeFunctionData(funcName, [amount]),
+  }));
+}
+
+function decodeReaderResult(
+  results: Result,
+  readerIface: Interface,
+  funcName: string,
+) {
+  return results.map(result => {
+    const parsed = readerIface.decodeFunctionResult(funcName, result);
+    return BigInt(parsed[0]._hex);
+  });
+}
+
+async function checkOnChainPricing(
+  stkGHO: StkGHO,
+  funcName: string,
+  blockNumber: number,
+  prices: bigint[],
+  amounts: bigint[],
+) {
+  const exchangeAddress = '0x1a88Df1cFe15Af22B3c4c783D4e6F7F9e0C1885d';
+  const readerIface = new Interface(StkGHO_ABI);
+
+  const readerCallData = getReaderCalldata(
+    exchangeAddress,
+    readerIface,
+    amounts.slice(1),
+    funcName,
+  );
+  const readerResult = (
+    await stkGHO.dexHelper.multiContract.methods
+      .aggregate(readerCallData)
+      .call({}, blockNumber)
+  ).returnData;
+
+  const expectedPrices = [0n].concat(
+    decodeReaderResult(readerResult, readerIface, funcName),
+  );
+
+  expect(prices).toEqual(expectedPrices);
+}
+
+async function testPricingOnNetwork(
+  stkGHO: StkGHO,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+) {
+  const networkTokens = Tokens[network];
+
+  const pools = await stkGHO.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await stkGHO.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  if (stkGHO.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+
+  await checkOnChainPricing(
+    stkGHO,
+    funcNameToCheck,
+    blockNumber,
+    poolPrices![0].prices,
+    amounts,
+  );
+}
+
+describe('StkGHO', function () {
+  const dexKey = 'StkGHO';
+  let blockNumber: number;
+  let stkGHO: StkGHO;
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    // Don't forget to update relevant tokens in constant-e2e.ts
+    const srcTokenSymbol = 'GHO';
+    const destTokenSymbol = 'stkGHO';
+
+    const amountsForSell = [
+      0n,
+      1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+    ];
+
+    const amountsForBuy = [
+      0n,
+      1n * BI_POWS[tokens[destTokenSymbol].decimals],
+      2n * BI_POWS[tokens[destTokenSymbol].decimals],
+      3n * BI_POWS[tokens[destTokenSymbol].decimals],
+      4n * BI_POWS[tokens[destTokenSymbol].decimals],
+      5n * BI_POWS[tokens[destTokenSymbol].decimals],
+      6n * BI_POWS[tokens[destTokenSymbol].decimals],
+      7n * BI_POWS[tokens[destTokenSymbol].decimals],
+      8n * BI_POWS[tokens[destTokenSymbol].decimals],
+      9n * BI_POWS[tokens[destTokenSymbol].decimals],
+      10n * BI_POWS[tokens[destTokenSymbol].decimals],
+    ];
+
+    beforeAll(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      stkGHO = new StkGHO(network, dexKey, dexHelper);
+      if (stkGHO.initializePricing) {
+        await stkGHO.initializePricing(blockNumber);
+      }
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+      await testPricingOnNetwork(
+        stkGHO,
+        network,
+        dexKey,
+        blockNumber,
+        srcTokenSymbol,
+        destTokenSymbol,
+        SwapSide.SELL,
+        amountsForSell,
+        'previewStake',
+      );
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+      await testPricingOnNetwork(
+        stkGHO,
+        network,
+        dexKey,
+        blockNumber,
+        srcTokenSymbol,
+        destTokenSymbol,
+        SwapSide.BUY,
+        amountsForBuy,
+        'previewStake',
+      );
+    });
+
+    it('getTopPoolsForToken', async function () {
+      // We have to check without calling initializePricing, because
+      // pool-tracker is not calling that function
+      const newStkGHO = new StkGHO(network, dexKey, dexHelper);
+      if (newStkGHO.updatePoolState) {
+        await newStkGHO.updatePoolState();
+      }
+      const poolLiquidity = await newStkGHO.getTopPoolsForToken(
+        tokens[srcTokenSymbol].address,
+        10,
+      );
+      console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
+
+      if (!newStkGHO.hasConstantPriceLargeAmounts) {
+        checkPoolsLiquidity(
+          poolLiquidity,
+          Tokens[network][srcTokenSymbol].address,
+          dexKey,
+        );
+      }
+    });
+  });
+});