@paraswap/dex-lib 3.11.8 → 3.11.10-stader.0

package/src/dex/stader/stader.ts

@@ -0,0 +1,240 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { NumberAsString, SwapSide } from '@paraswap/core';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  ExchangePrices,
+  Logger,
+  PoolLiquidity,
+  PoolPrices,
+  Token,
+  TransferFeeParams,
+} from '../../types';
+import { IDexTxBuilder } from '../idex';
+import SSPMAbi from '../../abi/SSPM.json';
+import StadeOracleAbi from '../../abi/StaderOracle.json';
+import { ETHER_ADDRESS, Network, NULL_ADDRESS } from '../../constants';
+import { IDexHelper } from '../../dex-helper';
+import { SimpleExchange } from '../simple-exchange';
+import { BI_POWS } from '../../bigint-constants';
+import { AsyncOrSync } from 'ts-essentials';
+import { ETHxEventPool } from './stader-pool';
+import { StaderData, SSPMFunctions } from './types';
+import { StaderConfig } from './config';
+import { WethFunctions } from '../weth/types';
+import ERC20ABI from '../../abi/erc20.json';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import _ from 'lodash';
+import { extractReturnAmountPosition } from '../../executor/utils';
+import { getDexKeysWithNetwork, isETHAddress } from '../../utils';
+
+export class Stader
+  extends SimpleExchange
+  implements IDexTxBuilder<StaderData, any>
+{
+  static dexKeys = ['Stader'];
+  ETHxAddress: string;
+  SSPM_Address: string;
+  SSPMInterface: Interface;
+  StaderOracleAddress: string;
+  StaderOracleInterface: Interface;
+  erc20Interface: Interface;
+  needWrapNative = false;
+  ethxPool: ETHxEventPool;
+  logger: Logger;
+  hasConstantPriceLargeAmounts: boolean = true;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(StaderConfig, ['Stader']));
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    dexHelper: IDexHelper,
+    protected config = StaderConfig[dexKey][network],
+  ) {
+    super(dexHelper, 'Stader');
+    this.network = dexHelper.config.data.network;
+    this.ETHxAddress = this.config.ETHx.toLowerCase();
+    this.SSPM_Address = this.config.SSPM.toLowerCase();
+    this.SSPMInterface = new Interface(SSPMAbi as JsonFragment[]);
+    this.StaderOracleAddress = this.config.StaderOracle.toLowerCase();
+    this.StaderOracleInterface = new Interface(
+      StadeOracleAbi as JsonFragment[],
+    );
+    this.erc20Interface = new Interface(ERC20ABI);
+    this.logger = dexHelper.getLogger(this.dexKey);
+    this.ethxPool = new ETHxEventPool(
+      this.dexKey,
+      dexHelper,
+      this.StaderOracleAddress,
+      this.StaderOracleInterface,
+      this.logger,
+    );
+  }
+
+  getAdapterParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: StaderData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: NULL_ADDRESS,
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  async initializePricing(blockNumber: number) {
+    await this.ethxPool.initialize(blockNumber);
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amountsIn: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[] | undefined,
+    transferFees?: TransferFeeParams | undefined,
+    isFirstSwap?: boolean | undefined,
+  ): Promise<ExchangePrices<StaderData> | null> {
+    if (side === SwapSide.BUY) return null;
+    if (!this.isEligibleSwap(srcToken, destToken)) return null;
+
+    const pool = this.ethxPool;
+    if (!pool.getState(blockNumber)) return null;
+
+    const unitIn = BI_POWS[18];
+    const unitOut = pool.getPrice(blockNumber, unitIn);
+    const amountsOut = amountsIn.map(amountIn =>
+      pool.getPrice(blockNumber, amountIn),
+    );
+
+    return [
+      {
+        prices: amountsOut,
+        unit: unitOut,
+        data: {},
+        exchange: this.dexKey,
+        poolIdentifier: `${ETHER_ADDRESS}_${destToken.address}`.toLowerCase(),
+        gasCost: 120_000,
+        poolAddresses: [destToken.address],
+      },
+    ];
+  }
+
+  isEligibleSwap(srcToken: Token | string, destToken: Token | string): boolean {
+    const srcTokenAddress = (
+      typeof srcToken === 'string' ? srcToken : srcToken.address
+    ).toLowerCase();
+    const destTokenAddress = (
+      typeof destToken === 'string' ? destToken : destToken.address
+    ).toLowerCase();
+
+    return (
+      (isETHAddress(srcTokenAddress) || this.isWETH(srcTokenAddress)) &&
+      destTokenAddress === this.ETHxAddress
+    );
+  }
+
+  getDexParam(
+    srcToken: Address,
+    _destToken: Address,
+    srcAmount: NumberAsString,
+    _destAmount: NumberAsString,
+    _recipient: Address,
+    _data: StaderData,
+    _side: SwapSide,
+  ): DexExchangeParam {
+    if (_side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const swapData = this.SSPMInterface.encodeFunctionData(
+      SSPMFunctions.deposit,
+      [_recipient],
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: this.config.SSPM.toLowerCase(),
+      preSwapUnwrapCalldata: this.isWETH(srcToken)
+        ? this.erc20Interface.encodeFunctionData(WethFunctions.withdraw, [
+            srcAmount,
+          ])
+        : undefined,
+      returnAmountPos:
+        _side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.SSPMInterface,
+              SSPMFunctions.deposit,
+            )
+          : undefined,
+    };
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    if (side === SwapSide.BUY) return [];
+
+    if (!this.isEligibleSwap(srcToken, destToken)) return [];
+
+    return [`${ETHER_ADDRESS}_${destToken.address}`.toLowerCase()];
+  }
+
+  getCalldataGasCost(poolPrices: PoolPrices<StaderData>): number | number[] {
+    return CALLDATA_GAS_COST.DEX_OVERHEAD + CALLDATA_GAS_COST.LENGTH_SMALL;
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return null;
+  }
+
+  getTopPoolsForToken(
+    tokenAddress: string,
+    limit: number,
+  ): AsyncOrSync<PoolLiquidity[]> {
+    if (isETHAddress(tokenAddress) || this.isWETH(tokenAddress.toLowerCase())) {
+      return [
+        {
+          exchange: this.dexKey,
+          address: this.config.ETHx,
+          connectorTokens: [
+            {
+              decimals: 18,
+              address: this.config.ETHx,
+            },
+          ],
+          liquidityUSD: 1000000000,
+        },
+      ];
+    }
+
+    if (tokenAddress.toLowerCase() === this.ETHxAddress.toLowerCase()) {
+      const eth = ETHER_ADDRESS;
+      const weth = this.dexHelper.config.data.wrappedNativeTokenAddress;
+      return [eth, weth].map(t => ({
+        exchange: this.dexKey,
+        address: this.config.ETHx,
+        connectorTokens: [
+          {
+            decimals: 18,
+            address: t,
+          },
+        ],
+        liquidityUSD: 1000000000,
+      }));
+    }
+
+    return [];
+  }
+}

package/src/dex/stader/types.ts

@@ -0,0 +1,16 @@
+export type ETHxPoolState = {
+  totalETHBalance: bigint;
+  totalETHXSupply: bigint;
+};
+
+export type StaderData = {};
+
+export type DexParams = {
+  ETHx: string;
+  SSPM: string;
+  StaderOracle: string;
+};
+
+export enum SSPMFunctions {
+  deposit = 'deposit',
+}

package/src/dex/stader/utils.ts

@@ -0,0 +1,34 @@
+import { Contract } from 'web3-eth-contract';
+import { ETHxPoolState } from './types';
+import { Interface, AbiCoder } from '@ethersproject/abi';
+import { BI_POWS } from '../../bigint-constants';
+
+export async function getOnChainStateETHx(
+  multiContract: Contract,
+  poolAddress: string,
+  poolInterface: Interface,
+  blockNumber: number | 'latest',
+): Promise<ETHxPoolState> {
+  const coder = new AbiCoder();
+  const data: { returnData: any[] } = await multiContract.methods
+    .aggregate([
+      {
+        target: poolAddress,
+        callData: poolInterface.encodeFunctionData('getExchangeRate', []),
+      },
+    ])
+    .call({}, blockNumber);
+
+  const decodedData = coder.decode(
+    ['uint256', 'uint256', 'uint256'],
+    data.returnData[0],
+  );
+
+  const totalETHBalance = BigInt(decodedData[1].toString());
+  const totalETHXSupply = BigInt(decodedData[2].toString());
+
+  return {
+    totalETHBalance,
+    totalETHXSupply,
+  };
+}

package/src/dex/uniswap-v3/uniswap-v3-pool.ts

@@ -254,36 +254,6 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     return TICK_BITMAP_TO_USE + TICK_BITMAP_BUFFER;
   }
 
-  async getOrGenerateState(
-    blockNumber: number,
-  ): Promise<DeepReadonly<PoolState> | null> {
-    const state = this.getState(blockNumber);
-    if (state) {
-      return state;
-    }
-
-    this.logger.error(
-      `UniV3: No state found for ${this.name} ${this.addressesSubscribed[0]}, generating new one`,
-    );
-    try {
-      const newState = await this.generateState(blockNumber);
-
-      if (!newState) {
-        this.logger.error(
-          `UniV3: Could not generate state for ${this.name} ${this.addressesSubscribed[0]}`,
-        );
-        return null;
-      }
-      this.setState(newState, blockNumber);
-      return newState;
-    } catch (error) {
-      this.logger.error(
-        `UniV3: Failed to generate state for ${this.name} ${this.addressesSubscribed[0]}`,
-      );
-      return null;
-    }
-  }
-
   async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
     const callData = this._getStateRequestCallData();
 

package/src/dex/uniswap-v3/uniswap-v3.ts

@@ -715,10 +715,6 @@ export class UniswapV3
 
       if (selectedPools.length === 0) return null;
 
-      await Promise.all(
-        selectedPools.map(pool => pool.getOrGenerateState(blockNumber)),
-      );
-
       const poolsToUse = selectedPools.reduce(
         (acc, pool) => {
           let state = pool.getState(blockNumber);
@@ -726,7 +722,6 @@ export class UniswapV3
             this.logger.trace(
               `${this.dexKey}: State === null. Fallback to rpc ${pool.name}`,
             );
-            // as we generate state (if nullified) in previous Promise.all, here should only be pools with failed initialization
             acc.poolWithoutState.push(pool);
           } else {
             acc.poolWithState.push(pool);
@@ -739,12 +734,6 @@ export class UniswapV3
         },
       );
 
-      poolsToUse.poolWithoutState.forEach(pool => {
-        this.logger.warn(
-          `UniV3: Pool ${pool.name} on ${this.dexKey} has no state. Fallback to rpc`,
-        );
-      });
-
       const states = poolsToUse.poolWithState.map(
         p => p.getState(blockNumber)!,
       );

package/tests/constants-e2e.ts

@@ -92,6 +92,10 @@ export const Tokens: {
       address: ETHER_ADDRESS,
       decimals: 18,
     },
+    ETHx: {
+      address: '0xA35b1B31Ce002FBF2058D22F30f95D405200A15b',
+      decimals: 18,
+    },
     SWETH: {
       address: '0xf951e335afb289353dc249e82926178eac7ded78',
       decimals: 18,
@@ -1625,6 +1629,7 @@ export const Holders: {
     sUSDS: '0xd564B3aE673CAa49D054Bf185bD72a6853763eE7',
     SKY: '0x0ddda327A6614130CCb20bc0097313A282176A01',
     MKR: '0xe9aAA7A9DDc0877626C1779AbC29993aD89A6c1f',
+    ETHx: '0xFCC1A2c71F01B7f58Ed538a6B4AAa5A0724eB5A6',
     // Idle tokens
     AA_wstETH: '0xd7C1b48877A7dFA7D51cf1144c89C0A3F134F935',
     'AA_idle_cpPOR-USDC': '0x085c8eaccA6911fE60aE3f8FbAe5F3012E3A05Ec',

package/.vscode/launch.json

@@ -1,53 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Current",
-      "program": "${file}",
-      "preLaunchTask": "npm: build",
-      "sourceMaps": true,
-      "smartStep": true,
-      "internalConsoleOptions": "openOnSessionStart",
-      "outFiles": ["${workspaceFolder}/build/**/*.js"]
-    },
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Debug dex integration",
-      "program": "${workspaceFolder}/node_modules/ts-node/dist/bin.js",
-      "args": [
-        "--project",
-        "tsconfig.json",
-        // "${workspaceFolder}/src/dex/algebra/scripts/validate-state.ts",
-        "${workspaceFolder}/src/dex/camelot/camelot-pool-discovery.test.ts",
-        // "${workspaceFolder}/src/dex/solidly-v3/scripts/check-event-pool-event.ts",
-        // "${workspaceFolder}/scripts/dex-integration.ts",
-        "test",
-        "wombat"
-      ],
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "runtimeArgs": ["--nolazy"],
-      "sourceMaps": true,
-      "smartStep": true,
-      "skipFiles": ["<node_internals>/**"],
-      "cwd": "${workspaceFolder}"
-    },
-    {
-      "type": "node",
-      "name": "Jest file",
-      "request": "launch",
-      "program": "${workspaceFolder}/node_modules/jest/bin/jest.js",
-      // "program": "${workspaceFolder}/src/dex/camelot/scripts/validate-state.ts",
-      // "args": ["src/dex/balancer-v1/balancer-v1-e2e.test.ts"],
-      // "args": ["${relativeFile}"],
-      "args": ["${file}"],
-      "cwd": "${workspaceRoot}",
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "sourceMaps": true
-    }
-  ]
-}

package/.vscode/settings.json

@@ -1,2 +0,0 @@
-{
-}

package/.vscode/tasks.json

@@ -1,15 +0,0 @@
-{
-  "version": "2.0.0",
-  "tasks": [
-    {
-      "label": "tsc: build - tsconfig.json",
-      "type": "typescript",
-      "tsconfig": "tsconfig.json",
-      "problemMatcher": ["$tsc"],
-      "group": {
-        "kind": "build",
-        "isDefault": true
-      }
-    }
-  ]
-}