@paraswap/dex-lib 2.50.8 → 2.50.9

package/src/dex/angle-staked-stable/angle-staked-stable-pool.ts

@@ -0,0 +1,325 @@
+import { Interface } from '@ethersproject/abi';
+import type { DeepReadonly } from 'ts-essentials';
+import type { BlockHeader, Log, Logger } from '../../types';
+import {
+  bigIntify,
+  catchParseLogError,
+  currentBigIntTimestampInS,
+} from '../../utils';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import type { IDexHelper } from '../../dex-helper/idex-helper';
+import type { PoolState } from './types';
+import StakedStableABI from '../../abi/angle/stagToken.json';
+import ERC20ABI from '../../abi/erc20.json';
+
+export class AngleStakedStableEventPool extends StatefulEventSubscriber<PoolState> {
+  handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<PoolState>,
+      log: Readonly<Log>,
+      blockHeader: Readonly<BlockHeader>,
+    ) => DeepReadonly<PoolState> | null;
+  } = {};
+
+  static angleStakedStableIface = new Interface(StakedStableABI);
+  static erc20Iface = new Interface(ERC20ABI);
+
+  logDecoder: (log: Log) => any;
+
+  addressesSubscribed: string[];
+
+  BASE_27 = BigInt(1e27);
+  HALF_BASE_27 = BigInt(1e27 / 2);
+  ZERO = BigInt(0);
+
+  constructor(
+    readonly parentName: string,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    public stakeToken: string,
+    public agToken: string,
+    logger: Logger,
+  ) {
+    super(
+      parentName,
+      `${parentName}_${stakeToken.toLowerCase()}`,
+      dexHelper,
+      logger,
+    );
+
+    this.logDecoder = (log: Log) =>
+      AngleStakedStableEventPool.angleStakedStableIface.parseLog(log);
+    this.addressesSubscribed = [stakeToken];
+
+    // Add handlers
+    this.handlers.Accrued = this.handleAccrued.bind(this);
+    this.handlers.Deposit = this.handleDeposit.bind(this);
+    this.handlers.Withdraw = this.handleWithdraw.bind(this);
+    this.handlers.ToggledPause = this.handleToggledPause.bind(this);
+    this.handlers.RateUpdated = this.handleRateUpdated.bind(this);
+  }
+
+  /**
+   * 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>,
+    blockHeader: Readonly<BlockHeader>,
+  ): DeepReadonly<PoolState> | null {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        return this.handlers[event.name](event, state, log, blockHeader);
+      }
+    } 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 poolState = {
+      totalAssets: 0n,
+      totalSupply: 0n,
+      lastUpdate: 0n,
+      paused: false,
+      rate: 0n,
+    } as PoolState;
+
+    const multicall = [
+      {
+        target: this.agToken,
+        callData: AngleStakedStableEventPool.erc20Iface.encodeFunctionData(
+          'balanceOf',
+          [this.stakeToken],
+        ),
+      },
+      {
+        target: this.stakeToken,
+        callData:
+          AngleStakedStableEventPool.angleStakedStableIface.encodeFunctionData(
+            'totalSupply',
+          ),
+      },
+      {
+        target: this.stakeToken,
+        callData:
+          AngleStakedStableEventPool.angleStakedStableIface.encodeFunctionData(
+            'lastUpdate',
+          ),
+      },
+      {
+        target: this.stakeToken,
+        callData:
+          AngleStakedStableEventPool.angleStakedStableIface.encodeFunctionData(
+            'paused',
+          ),
+      },
+      {
+        target: this.stakeToken,
+        callData:
+          AngleStakedStableEventPool.angleStakedStableIface.encodeFunctionData(
+            'rate',
+          ),
+      },
+    ];
+
+    // on chain call
+    const returnData = (
+      await this.dexHelper.multiContract.methods
+        .aggregate(multicall)
+        .call({}, blockNumber)
+    ).returnData;
+
+    // Decode
+    poolState.totalAssets = bigIntify(
+      AngleStakedStableEventPool.erc20Iface.decodeFunctionResult(
+        'balanceOf',
+        returnData[0],
+      )[0],
+    );
+    poolState.totalSupply = bigIntify(
+      AngleStakedStableEventPool.angleStakedStableIface.decodeFunctionResult(
+        'totalSupply',
+        returnData[1],
+      )[0],
+    );
+    poolState.lastUpdate = bigIntify(
+      AngleStakedStableEventPool.angleStakedStableIface.decodeFunctionResult(
+        'lastUpdate',
+        returnData[2],
+      )[0],
+    );
+    poolState.paused =
+      AngleStakedStableEventPool.angleStakedStableIface.decodeFunctionResult(
+        'paused',
+        returnData[3],
+      )[0] as boolean;
+
+    poolState.rate = bigIntify(
+      AngleStakedStableEventPool.angleStakedStableIface.decodeFunctionResult(
+        'rate',
+        returnData[4],
+      )[0],
+    );
+
+    return poolState;
+  }
+
+  async getOrGenerateState(
+    blockNumber: number,
+  ): Promise<DeepReadonly<PoolState> | null> {
+    const state = this.getState(blockNumber);
+    if (state) {
+      return state;
+    }
+
+    this.logger.debug(
+      `No state found for ${this.addressesSubscribed[0]}, generating new one`,
+    );
+    const newState = await this.generateState(blockNumber);
+
+    if (!newState) {
+      this.logger.debug(
+        `Could not regenerate state for ${this.addressesSubscribed[0]}`,
+      );
+      return null;
+    }
+    this.setState(newState, blockNumber);
+    return newState;
+  }
+
+  getRateDeposit(amount: bigint, state: PoolState): bigint {
+    const newTotalAssets = this._accrue(state);
+    return amount === 0n || state.totalSupply === 0n
+      ? amount
+      : (amount * state.totalSupply) / newTotalAssets;
+  }
+
+  getRateMint(shares: bigint, state: PoolState): bigint {
+    const newTotalAssets = this._accrue(state);
+    const roundUp =
+      (shares * newTotalAssets) % state.totalSupply > 0n ? 1n : 0n;
+    return state.totalSupply === 0n
+      ? shares
+      : (shares * newTotalAssets) / state.totalSupply + roundUp;
+  }
+
+  getRateRedeem(shares: bigint, state: PoolState): bigint {
+    const newTotalAssets = this._accrue(state);
+    return state.totalSupply === 0n
+      ? shares
+      : (shares * newTotalAssets) / state.totalSupply;
+  }
+
+  getRateWithdraw(amount: bigint, state: PoolState): bigint {
+    const newTotalAssets = this._accrue(state);
+    const roundUp =
+      (amount * state.totalSupply) % newTotalAssets > 0n ? 1n : 0n;
+    return amount === 0n || state.totalSupply === 0n
+      ? amount
+      : (amount * state.totalSupply) / newTotalAssets + roundUp;
+  }
+
+  _accrue(state: PoolState): bigint {
+    const newTotalAssets = this._computeUpdatedAssets(
+      state.totalAssets,
+      state.rate,
+      currentBigIntTimestampInS() - state.lastUpdate,
+    );
+    return newTotalAssets;
+  }
+
+  _computeUpdatedAssets(amount: bigint, rate: bigint, exp: bigint): bigint {
+    if (exp === 0n || rate === 0n) return amount;
+    const expMinusOne = exp - 1n;
+    const expMinusTwo = exp > 2n ? exp - 2n : 0n;
+    const basePowerTwo = (rate * rate + this.HALF_BASE_27) / this.BASE_27;
+    const basePowerThree =
+      (basePowerTwo * rate + this.HALF_BASE_27) / this.BASE_27;
+    const secondTerm = (exp * expMinusOne * basePowerTwo) / 2n;
+    const thirdTerm = (exp * expMinusOne * expMinusTwo * basePowerThree) / 6n;
+    return (
+      (amount * (this.BASE_27 + rate * exp + secondTerm + thirdTerm)) /
+      this.BASE_27
+    );
+  }
+
+  handleAccrued(
+    event: any,
+    state: PoolState,
+    log: Readonly<Log>,
+    blockHeader: BlockHeader,
+  ): DeepReadonly<PoolState> | null {
+    const interest = bigIntify(event.args.interest);
+    state.totalAssets += interest;
+    state.lastUpdate = bigIntify(blockHeader.timestamp);
+    return state;
+  }
+
+  handleRateUpdated(
+    event: any,
+    state: PoolState,
+    log: Readonly<Log>,
+    blockHeader: BlockHeader,
+  ): DeepReadonly<PoolState> | null {
+    state.rate = bigIntify(event.args.newRate);
+    return state;
+  }
+
+  handleDeposit(
+    event: any,
+    state: PoolState,
+    log: Readonly<Log>,
+    blockHeader: BlockHeader,
+  ): DeepReadonly<PoolState> | null {
+    const assets = bigIntify(event.args.assets);
+    const shares = bigIntify(event.args.shares);
+    state.totalAssets += assets;
+    state.totalSupply += shares;
+    state.lastUpdate = bigIntify(blockHeader.timestamp);
+    return state;
+  }
+
+  handleWithdraw(
+    event: any,
+    state: PoolState,
+    log: Readonly<Log>,
+    blockHeader: BlockHeader,
+  ): DeepReadonly<PoolState> | null {
+    const assets = bigIntify(event.args.assets);
+    const shares = bigIntify(event.args.shares);
+    state.totalAssets -= assets;
+    state.totalSupply -= shares;
+    state.lastUpdate = bigIntify(blockHeader.timestamp);
+    return state;
+  }
+
+  handleToggledPause(
+    event: any,
+    state: PoolState,
+    log: Readonly<Log>,
+  ): DeepReadonly<PoolState> | null {
+    const pauseStatus: boolean = event.args.pauseStatus;
+    state.paused = pauseStatus;
+    return state;
+  }
+}

package/src/dex/angle-staked-stable/angle-staked-stable.ts

@@ -0,0 +1,312 @@
+import { Interface } from '@ethersproject/abi';
+import type { AsyncOrSync } from 'ts-essentials';
+import type {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  SimpleExchangeParam,
+  PoolLiquidity,
+  Logger,
+} from '../../types';
+import { SwapSide, type Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getDexKeysWithNetwork } from '../../utils';
+import type { IDex } from '../../dex/idex';
+import type { IDexHelper } from '../../dex-helper/idex-helper';
+import type { AngleStakedStableData, DexParams } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { AngleStakedStableConfig, Adapters } from './config';
+import { AngleStakedStableEventPool } from './angle-staked-stable-pool';
+
+const AngleStakedGasCost = 80000;
+
+export class AngleStakedStable
+  extends SimpleExchange
+  implements IDex<AngleStakedStableData>
+{
+  protected config: DexParams;
+
+  readonly hasConstantPriceLargeAmounts = false;
+  readonly needWrapNative = true;
+
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(AngleStakedStableConfig);
+
+  logger: Logger;
+
+  protected eventPools: { [key: string]: AngleStakedStableEventPool } = {};
+  protected isPaused: { [key: string]: boolean } = {};
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    protected adapters = Adapters[network] || {},
+  ) {
+    super(dexHelper, dexKey);
+    const config = AngleStakedStableConfig[dexKey][network];
+    this.logger = dexHelper.getLogger(dexKey);
+    this.config = {
+      stakeToken: config.stakeToken.toLowerCase(),
+      agToken: config.agToken.toLowerCase(),
+    };
+  }
+
+  async initializePricing(blockNumber: number) {
+    this.eventPools[this.config.stakeToken] = new AngleStakedStableEventPool(
+      this.dexKey,
+      this.network,
+      this.dexHelper,
+      this.config.stakeToken,
+      this.config.agToken,
+      this.logger,
+    );
+    await this.eventPools[this.config.stakeToken].initialize(blockNumber);
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return this.adapters[side] ? this.adapters[side] : null;
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    const knownInfo = this._knownAddress(srcToken, destToken);
+    if (!knownInfo.known) return [];
+    return [`${this.dexKey}_${knownInfo.stakeToken!.toLowerCase()}`];
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<AngleStakedStableData>> {
+    const srcTokenAddress = srcToken.address.toLowerCase();
+    const destTokenAddress = destToken.address.toLowerCase();
+    const knownInfo = this._knownAddress(srcToken, destToken);
+    if (!knownInfo.known) return null;
+
+    const agToken = knownInfo.agToken!;
+    const stakeToken = knownInfo.stakeToken!;
+    const eventPool = this.eventPools[stakeToken];
+    const exchange = `${this.dexKey}`;
+    const state = await eventPool?.getOrGenerateState(blockNumber);
+    if (this.eventPools === null || state === undefined || state === null)
+      return null;
+    if (srcTokenAddress === agToken && side === SwapSide.SELL)
+      return [
+        {
+          prices: amounts.map(amount =>
+            eventPool.getRateDeposit(amount, state),
+          ),
+          unit: eventPool.getRateDeposit(1n * BigInt(10 ** 18), state),
+          gasCost: AngleStakedGasCost,
+          exchange: exchange,
+          data: { exchange: stakeToken },
+          poolAddresses: [stakeToken],
+        },
+      ];
+    if (destTokenAddress === agToken && side === SwapSide.SELL)
+      return [
+        {
+          prices: amounts.map(share => eventPool.getRateRedeem(share, state)),
+          unit: eventPool.getRateRedeem(1n * BigInt(10 ** 18), state),
+          gasCost: AngleStakedGasCost,
+          exchange: exchange,
+          data: { exchange: stakeToken },
+          poolAddresses: [stakeToken],
+        },
+      ];
+    if (srcTokenAddress === agToken && side === SwapSide.BUY)
+      return [
+        {
+          prices: amounts.map(share => eventPool.getRateMint(share, state)),
+          unit: eventPool.getRateMint(1n * BigInt(10 ** 18), state),
+          gasCost: AngleStakedGasCost,
+          exchange: exchange,
+          data: { exchange: stakeToken },
+          poolAddresses: [stakeToken],
+        },
+      ];
+    return [
+      {
+        prices: amounts.map(amount => eventPool.getRateWithdraw(amount, state)),
+        unit: eventPool.getRateWithdraw(1n * BigInt(10 ** 18), state),
+        gasCost: AngleStakedGasCost,
+        exchange: exchange,
+        data: { exchange: stakeToken },
+        poolAddresses: [stakeToken],
+      },
+    ];
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(
+    poolPrices: PoolPrices<AngleStakedStableData>,
+  ): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: AngleStakedStableData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const { exchange } = data;
+
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          toStaked: 'bool',
+        },
+      },
+      {
+        toStaked: srcToken.toLowerCase() === this.config.agToken,
+      },
+    );
+
+    return {
+      targetExchange: exchange,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  // Encode call data used by simpleSwap like routers
+  // Used for simpleSwap & simpleBuy
+  // Hint: this.buildSimpleParamWithoutWETHConversion
+  // could be useful
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: AngleStakedStableData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const { exchange } = data;
+
+    // Encode here the transaction arguments
+    const swapData =
+      srcToken.toLowerCase() === this.config.agToken
+        ? AngleStakedStableEventPool.angleStakedStableIface.encodeFunctionData(
+            side === SwapSide.SELL ? 'deposit' : 'mint',
+            [
+              side === SwapSide.SELL ? srcAmount : destAmount,
+              this.augustusAddress,
+            ],
+          )
+        : AngleStakedStableEventPool.angleStakedStableIface.encodeFunctionData(
+            side === SwapSide.SELL ? 'redeem' : 'withdraw',
+            [
+              side === SwapSide.SELL ? srcAmount : destAmount,
+              this.augustusAddress,
+              this.augustusAddress,
+            ],
+          );
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      exchange,
+    );
+  }
+
+  // This is called once before getTopPoolsForToken is
+  // called for multiple tokens. This can be helpful to
+  // update common state required for calculating
+  // getTopPoolsForToken. It is optional for a DEX
+  // to implement this
+  async updatePoolState(): Promise<void> {
+    const tokenBalanceMultiCall = [
+      {
+        target: this.config.stakeToken,
+        callData:
+          AngleStakedStableEventPool.angleStakedStableIface.encodeFunctionData(
+            'paused',
+          ),
+      },
+    ];
+    const returnData = (
+      await this.dexHelper.multiContract.methods
+        .aggregate(tokenBalanceMultiCall)
+        .call()
+    ).returnData;
+
+    this.isPaused[this.config.stakeToken] =
+      AngleStakedStableEventPool.angleStakedStableIface.decodeFunctionResult(
+        'paused',
+        returnData[0],
+      )[0] as boolean;
+  }
+
+  // Returns list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    if (
+      this.isPaused[this.config.stakeToken] ||
+      (tokenAddress.toLowerCase() !== this.config.agToken &&
+        tokenAddress.toLowerCase() !== this.config.stakeToken)
+    ) {
+      return [];
+    }
+
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.config.stakeToken,
+        connectorTokens: [
+          tokenAddress.toLowerCase() === this.config.agToken
+            ? ({ address: this.config.stakeToken, decimals: 18 } as Token)
+            : ({ address: this.config.agToken, decimals: 18 } as Token),
+        ],
+        // liquidity is infinite as to have been able to mint stakeToken, you must have deposited agToken
+        liquidityUSD: 1e12,
+      },
+    ];
+  }
+
+  // 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> {}
+
+  _knownAddress(
+    srcToken: Token,
+    destToken: Token,
+  ): { known: boolean; agToken: string | null; stakeToken: string | null } {
+    const srcTokenAddress = srcToken.address.toLowerCase();
+    const destTokenAddress = destToken.address.toLowerCase();
+    if (
+      (srcTokenAddress === this.config.agToken &&
+        destTokenAddress === this.config.stakeToken) ||
+      (srcTokenAddress === this.config.stakeToken &&
+        destTokenAddress === this.config.agToken)
+    ) {
+      return {
+        known: true,
+        agToken: this.config.agToken,
+        stakeToken: this.config.stakeToken,
+      };
+    }
+    return { known: false, agToken: null, stakeToken: null };
+  }
+}