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

package/src/dex/stkgho/stkgho-pool.ts

@@ -0,0 +1,111 @@
+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 StkGHO_ABI from '../../abi/stkGHO.json';
+import { StkGHOConfig } from './config';
+import { uint256ToBigInt } from '../../lib/decoders';
+
+export class StkGHOEventPool extends StatefulEventSubscriber<PoolState> {
+  handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<PoolState>,
+      log: Readonly<Log>,
+    ) => DeepReadonly<PoolState> | null;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  addressesSubscribed: string[];
+
+  constructor(
+    readonly poolName: string,
+    readonly parentName: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    logger: Logger,
+    protected stkGHOIface = new Interface(StkGHO_ABI),
+  ) {
+    super(parentName, poolName, dexHelper, logger);
+
+    this.logDecoder = (log: Log) => this.stkGHOIface.parseLog(log);
+    this.addressesSubscribed = [StkGHOConfig[parentName][network].stkGHO];
+
+    this.handlers['ExchangeRateChanged'] =
+      this.handleExchangeRateChanged.bind(this);
+  }
+
+  getIdentifier(): string {
+    return `${this.parentName}`;
+  }
+
+  /**
+   * The function is called every time any of the subscribed
+   * addresses release log. The function accepts the current
+   * state, updates the state according to the log, and returns
+   * the updated state.
+   * @param state - Current state of event subscriber
+   * @param log - Log released by one of the subscribed addresses
+   * @returns Updates state of the event subscriber after the log
+   */
+  protected processLog(
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+  ): DeepReadonly<PoolState> | null {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        return this.handlers[event.name](event, state, log);
+      }
+    } catch (e) {
+      catchParseLogError(e, this.logger);
+    }
+
+    return null;
+  }
+
+  /**
+   * The function generates state using on-chain calls. This
+   * function is called to regenerate state if the event based
+   * system fails to fetch events and the local state is no
+   * more correct.
+   * @param blockNumber - Blocknumber for which the state should
+   * should be generated
+   * @returns state of the event subscriber at blocknumber
+   */
+  async generateState(blockNumber: number): Promise<DeepReadonly<PoolState>> {
+    const callData = [
+      {
+        target: this.addressesSubscribed[0],
+        callData: this.stkGHOIface.encodeFunctionData('getExchangeRate', []),
+        decodeFunction: uint256ToBigInt,
+      },
+    ];
+
+    const res = await this.dexHelper.multiWrapper.tryAggregate<bigint>(
+      true,
+      callData,
+      blockNumber,
+    );
+
+    const result = {
+      exchangeRate: res[0].returnData,
+    };
+
+    return result;
+  }
+
+  handleExchangeRateChanged(
+    event: any,
+    state: DeepReadonly<PoolState>,
+    log: Readonly<Log>,
+  ): DeepReadonly<PoolState> | null {
+    return {
+      exchangeRate: BigInt(event.args.exchangeRate),
+    };
+  }
+}

package/src/dex/stkgho/stkgho.ts

@@ -0,0 +1,221 @@
+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 { IDex } from '../../dex/idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { DexParams, PoolState, StkGHOData } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { StkGHOConfig } from './config';
+import { StkGHOEventPool } from './stkgho-pool';
+import { Interface } from '@ethersproject/abi';
+import StkGHO_ABI from '../../abi/stkGHO.json';
+
+export class StkGHO extends SimpleExchange implements IDex<StkGHOData> {
+  static readonly stkGHOInterface = new Interface(StkGHO_ABI);
+  protected eventPool: StkGHOEventPool;
+
+  readonly hasConstantPriceLargeAmounts = false;
+  readonly needWrapNative = true;
+
+  protected config: DexParams;
+
+  readonly isFeeOnTransferSupported = false;
+  readonly exchangeRateUnit = 1_000_000_000_000_000_000n;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(StkGHOConfig);
+
+  logger: Logger;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+    this.eventPool = new StkGHOEventPool(
+      dexKey,
+      dexKey,
+      network,
+      dexHelper,
+      this.logger,
+    );
+
+    const config = StkGHOConfig[dexKey][network];
+    this.config = {
+      stkGHO: config.stkGHO.toLowerCase(),
+      GHO: config.GHO.toLowerCase(),
+    };
+  }
+
+  async initializePricing(blockNumber: number) {
+    const state = await this.eventPool.generateState(blockNumber);
+
+    this.eventPool.initialize(blockNumber, {
+      state,
+    });
+  }
+
+  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.stkGHO
+    ) {
+      return [`${this.dexKey}`];
+    } else {
+      return [];
+    }
+  }
+
+  async getPoolState(blockNumber: number): Promise<PoolState> {
+    const eventState = this.eventPool.getState(blockNumber);
+    if (eventState) return eventState;
+    const onChainState = await this.eventPool.generateState(blockNumber);
+    this.eventPool.setState(onChainState, blockNumber);
+    return onChainState;
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<StkGHOData>> {
+    if (side === SwapSide.BUY) {
+      return null;
+    }
+
+    const srcTokenAddress = srcToken.address.toLowerCase();
+    const destTokenAddress = destToken.address.toLowerCase();
+
+    if (
+      srcTokenAddress != this.config.GHO ||
+      destTokenAddress != this.config.stkGHO
+    ) {
+      return null;
+    }
+
+    const state = await this.getPoolState(blockNumber);
+
+    return [
+      {
+        unit: state.exchangeRate,
+        prices: amounts.map(
+          amount => (state.exchangeRate * amount) / this.exchangeRateUnit,
+        ),
+        data: {
+          exchange: this.dexKey,
+        },
+        poolAddresses: [this.config.stkGHO],
+        exchange: this.dexKey,
+        gasCost: 100_000,
+        poolIdentifier: `${this.dexKey}`,
+      },
+    ];
+  }
+
+  getCalldataGasCost(poolPrices: PoolPrices<StkGHOData>): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: StkGHOData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const { exchange } = data;
+
+    const payload = '';
+
+    return {
+      targetExchange: exchange,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  async updatePoolState(): Promise<void> {}
+
+  async getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: StkGHOData,
+    side: SwapSide,
+  ): Promise<DexExchangeParam> {
+    const exchangeData = StkGHO.stkGHOInterface.encodeFunctionData('stake', [
+      recipient,
+      srcAmount,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: this.config.stkGHO,
+      returnAmountPos: undefined,
+    };
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    tokenAddress = tokenAddress.toLowerCase();
+
+    if (tokenAddress == this.config.GHO) {
+      return [
+        {
+          exchange: this.dexKey,
+          address: this.config.stkGHO,
+          connectorTokens: [
+            {
+              decimals: 18,
+              address: this.config.stkGHO,
+            },
+          ],
+          liquidityUSD: 1_000_000_000_000, // GHO to stkGHO supply is unlimited
+        },
+      ];
+    } else {
+      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> {}
+}

package/src/dex/stkgho/types.ts

@@ -0,0 +1,14 @@
+import { Address } from '../../types';
+
+export type PoolState = {
+  exchangeRate: bigint;
+};
+
+export type StkGHOData = {
+  exchange: Address;
+};
+
+export type DexParams = {
+  stkGHO: Address;
+  GHO: Address;
+};

package/tests/constants-e2e.ts

@@ -455,6 +455,10 @@ export const Tokens: {
       address: '0x40d16fc0246ad3160ccc09b8d0d3a2cd28ae6c2f',
       decimals: 18,
     },
+    stkGHO: {
+      address: '0x1a88Df1cFe15Af22B3c4c783D4e6F7F9e0C1885d',
+      decimals: 18,
+    },
     USDe: {
       address: '0x4c9EDD5852cd905f086C759E8383e09bff1E68B3',
       decimals: 18,