@paraswap/dex-lib 3.8.25 → 3.8.26-aave-gsm.2

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

@@ -0,0 +1,369 @@
+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 } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { AaveGsmConfig } from './config';
+
+import GSM_ABI from '../../abi/Aave_GSM.json';
+import { Interface } from '@ethersproject/abi';
+import { MultiResult } from '../../lib/multi-wrapper';
+import { BytesLike } from 'ethers';
+import { generalDecoder } from '../../lib/decoders';
+import { parseUnits } from 'ethers/lib/utils';
+import { extractReturnAmountPosition } from '../../executor/utils';
+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 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);
+  }
+
+  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 [];
+    }
+  }
+
+  // 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<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: string;
+    let target: string;
+    let resultIsGho: boolean;
+    if (srcTokenAddress == this.config.GHO && side == SwapSide.BUY) {
+      endpoint = 'getGhoAmountForBuyAsset';
+      resultIsGho = true;
+    } else if (srcTokenAddress == this.config.GHO && side == SwapSide.SELL) {
+      endpoint = 'getAssetAmountForBuyAsset';
+      resultIsGho = false;
+    } else if (destTokenAddress == this.config.GHO && side == SwapSide.SELL) {
+      endpoint = 'getGhoAmountForSellAsset';
+      resultIsGho = true;
+    } else {
+      endpoint = 'getAssetAmountForSellAsset';
+      resultIsGho = false;
+    }
+
+    if (
+      srcTokenAddress == this.config.USDT ||
+      destTokenAddress == this.config.USDT
+    ) {
+      target = this.config.GSM_USDT;
+    } else {
+      target = this.config.GSM_USDC;
+    }
+
+    const unit = parseUnits(
+      '1',
+      side == SwapSide.SELL ? srcToken.decimals : destToken.decimals,
+    ).toBigInt();
+
+    const amountsWithUnit = [...amounts, unit];
+
+    const calls = amountsWithUnit.map(amount => ({
+      target,
+      callData: AaveGsm.gsmInterface.encodeFunctionData(endpoint, [amount]),
+      decodeFunction: (
+        result: MultiResult<BytesLike> | BytesLike,
+      ): { underlying: bigint; gho: bigint } => {
+        return generalDecoder(
+          result,
+          ['uint256', 'uint256', 'uint256', 'uint256'],
+          {
+            underlying: 0n,
+            gho: 0n,
+          },
+          value => ({
+            underlying: value[0].toBigInt(),
+            gho: value[1].toBigInt(),
+          }),
+        );
+      },
+    }));
+
+    let results = await this.dexHelper.multiWrapper.tryAggregate<{
+      underlying: bigint;
+      gho: bigint;
+    }>(true, calls, blockNumber);
+
+    const unitPriceResult = results.pop()!;
+
+    return [
+      {
+        unit: resultIsGho
+          ? unitPriceResult.returnData.gho
+          : unitPriceResult.returnData.underlying,
+        prices: results.map(result =>
+          resultIsGho ? result.returnData.gho : result.returnData.underlying,
+        ),
+        data: {
+          exchange: this.dexKey,
+        },
+        poolAddresses: [target],
+        exchange: this.dexKey,
+        gasCost: endpoint.indexOf('BuyAsset') > 0 ? 80000 : 74000,
+        poolIdentifier: `${this.dexKey}_${target}`,
+      },
+    ];
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  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 endpoint = isSrcGho
+        ? 'getAssetAmountForBuyAsset'
+        : 'getAssetAmountForSellAsset';
+
+      const calldata = {
+        target: targetExchange,
+        callData: AaveGsm.gsmInterface.encodeFunctionData(endpoint, [
+          ghoAmount,
+        ]),
+        decodeFunction: (
+          result: MultiResult<BytesLike> | BytesLike,
+        ): { underlying: bigint; gho: bigint } => {
+          return generalDecoder(
+            result,
+            ['uint256', 'uint256', 'uint256', 'uint256'],
+            {
+              underlying: 0n,
+              gho: 0n,
+            },
+            value => ({
+              underlying: value[0].toBigInt(),
+              gho: value[1].toBigInt(),
+            }),
+          );
+        },
+      };
+
+      const result = await this.dexHelper.multiWrapper.tryAggregate<{
+        underlying: bigint;
+        gho: bigint;
+      }>(true, [calldata]);
+
+      assetAmount = result[0].returnData.underlying.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_32
+            : RETURN_AMOUNT_POS_0
+          : undefined,
+    };
+  }
+
+  // Returns list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    tokenAddress = tokenAddress.toLowerCase();
+
+    if (tokenAddress == this.config.GHO) {
+      return [
+        {
+          exchange: this.dexKey,
+          address: this.config.GSM_USDC,
+          connectorTokens: [
+            {
+              decimals: 6,
+              address: this.config.USDC,
+            },
+          ],
+          liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
+        },
+        {
+          exchange: this.dexKey,
+          address: this.config.GSM_USDT,
+          connectorTokens: [
+            {
+              decimals: 6,
+              address: this.config.USDT,
+            },
+          ],
+          liquidityUSD: 1000000000, // Just returning a big number so this DEX will be preferred
+        },
+      ];
+    } 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, AdapterMappings } from '../../types';
+import { Network, SwapSide } 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,15 @@
+import { Address } from '../../types';
+
+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;
+};

package/src/dex/generic-rfq/rate-fetcher.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { isEmpty } from 'lodash';
+import { isEmpty, omit } from 'lodash';
 import { SwapSide } from '@paraswap/core';
 import { BN_1 } from '../../bignumber-constants';
 import { IDexHelper } from '../../dex-helper';
@@ -433,14 +433,15 @@ export class RateFetcher {
         timeout: GET_FIRM_RATE_TIMEOUT_MS,
       };
 
+      this.logger.info(
+        'FirmRate Request:',
+        JSON.stringify(omit(payload, 'secret')).replace(/(?:\r\n|\r|\n)/g, ' '),
+      );
+
       if (this.firmRateAuth) {
         this.firmRateAuth(payload);
         delete payload.secret;
       }
-      this.logger.info(
-        'FirmRate Request:',
-        JSON.stringify(payload).replace(/(?:\r\n|\r|\n)/g, ' '),
-      );
       const { data } = await this.dexHelper.httpRequest.request<unknown>(
         payload,
       );

package/src/dex/index.ts

@@ -86,6 +86,7 @@ import { AaveV3Stata } from './aave-v3-stata/aave-v3-stata';
 import { OSwap } from './oswap/oswap';
 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';
 
 const LegacyDexes = [
@@ -168,6 +169,7 @@ const Dexes = [
   OSwap,
   ConcentratorArusd,
   FxProtocolRusd,
+  AaveGsm,
   LitePsm,
 ];
 

package/.vscode/launch.json

@@ -1,16 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "args": [
-        "${workspaceFolder}/src/dex/maverick-v2/maverick-v2-integration.test.ts"
-      ],
-      "internalConsoleOptions": "openOnSessionStart",
-      "name": "Dex-lib",
-      "program": "${workspaceFolder}/node_modules/jest/bin/jest",
-      "request": "launch",
-      "skipFiles": ["<node_internals>/**"],
-      "type": "node"
-    }
-  ]
-}

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "typescript.tsdk": "node_modules/typescript/lib"
-}