@paraswap/dex-lib 3.8.28 → 3.8.29-stkgho

package/src/dex/stkgho/stkgho.ts

@@ -0,0 +1,217 @@
+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>> {
+    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/src/dex/swaap-v2/swaap-v2.ts

@@ -524,7 +524,7 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
         normalizedDestToken,
         isSell ? optimalSwapExchange.srcAmount : optimalSwapExchange.destAmount,
         isSell ? SWAAP_ORDER_TYPE_SELL : SWAAP_ORDER_TYPE_BUY,
-        options.txOrigin,
+        options.userAddress,
         options.executionContractAddress,
         options.recipient,
         tolerance,
@@ -636,14 +636,14 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
       ];
     } catch (e) {
       if (isAxiosError(e) && e.response?.status === 403) {
-        await this.setBlacklist(options.txOrigin, SWAAP_403_TTL_S);
+        await this.setBlacklist(options.userAddress, SWAAP_403_TTL_S);
         this.logger.warn(
-          `${this.dexKey}-${this.network}: Encountered blacklisted user=${options.txOrigin}. Adding to local blacklist cache`,
+          `${this.dexKey}-${this.network}: Encountered blacklisted user=${options.userAddress}. Adding to local blacklist cache`,
         );
       } else if (isAxiosError(e) && e.response?.status === 429) {
-        await this.setBlacklist(options.txOrigin, SWAAP_429_TTL_S);
+        await this.setBlacklist(options.userAddress, SWAAP_429_TTL_S);
         this.logger.warn(
-          `${this.dexKey}-${this.network}: Encountered restricted user=${options.txOrigin}. Adding to local blacklist cache`,
+          `${this.dexKey}-${this.network}: Encountered restricted user=${options.userAddress}. Adding to local blacklist cache`,
         );
       } else {
         if (e instanceof TooStrictSlippageCheckError) {

package/src/implementations/local-paraswap-sdk.ts

@@ -282,6 +282,7 @@ export class LocalParaswapSDK implements IParaSwapSDK {
                         {
                           slippageFactor,
                           txOrigin: userAddress,
+                          userAddress,
                           executionContractAddress,
                           isDirectMethod: DirectContractMethods.includes(
                             contractMethod as ContractMethod,

package/src/types.ts

@@ -318,6 +318,7 @@ export type ExchangeTxInfo = {
 export type PreprocessTransactionOptions = {
   slippageFactor: BigNumber;
   txOrigin: Address;
+  userAddress: Address;
   executionContractAddress: Address;
   hmac?: string;
   mockRfqAndLO?: boolean;

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,

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
-      }
-    }
-  ]
-}

package/build/abi/uniswap-v3/AlienBaseV3Router.abi.json

@@ -1,52 +0,0 @@
-[
-    {
-        "inputs": [
-            {
-                "components": [
-                    { "internalType": "bytes", "name": "path", "type": "bytes" },
-                    { "internalType": "address", "name": "recipient", "type": "address" },
-                    { "internalType": "uint256", "name": "amountIn", "type": "uint256" },
-                    {
-                        "internalType": "uint256",
-                        "name": "amountOutMinimum",
-                        "type": "uint256"
-                    }
-                ],
-                "internalType": "struct ISwapRouter.ExactInputParams",
-                "name": "params",
-                "type": "tuple"
-            }
-        ],
-        "name": "exactInput",
-        "outputs": [
-            { "internalType": "uint256", "name": "amountOut", "type": "uint256" }
-        ],
-        "stateMutability": "payable",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "components": [
-                    { "internalType": "bytes", "name": "path", "type": "bytes" },
-                    { "internalType": "address", "name": "recipient", "type": "address" },
-                    { "internalType": "uint256", "name": "amountOut", "type": "uint256" },
-                    {
-                        "internalType": "uint256",
-                        "name": "amountInMaximum",
-                        "type": "uint256"
-                    }
-                ],
-                "internalType": "struct ISwapRouter.ExactOutputParams",
-                "name": "params",
-                "type": "tuple"
-            }
-        ],
-        "name": "exactOutput",
-        "outputs": [
-            { "internalType": "uint256", "name": "amountIn", "type": "uint256" }
-        ],
-        "stateMutability": "payable",
-        "type": "function"
-    }
-]