@paraswap/dex-lib 2.45.0 → 3.0.0

package/src/dex/woo-fi-v2/woo-fi-v2.ts

@@ -7,6 +7,8 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network, NULL_ADDRESS } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -25,6 +27,7 @@ import { ethers } from 'ethers';
 import { addressDecode } from '../../lib/decoders';
 import { ifaces } from './utils';
 import { StatePollingManager } from '../../lib/stateful-rpc-poller/state-polling-manager';
+import { solidityPack } from 'ethers/lib/utils';
 
 export class WooFiV2 extends SimpleExchange implements IDex<WooFiV2Data> {
   readonly math: WooFiV2Math;
@@ -318,6 +321,45 @@ export class WooFiV2 extends SimpleExchange implements IDex<WooFiV2Data> {
     };
   }
 
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: WooFiV2Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+
+    const _srcToken = srcToken.toLowerCase();
+    const _destToken = destToken.toLowerCase();
+
+    let rebateTo = this.rebateTo;
+    if (rebateTo === undefined) {
+      this.logger.error(`rebateTo is undefined in getDexParam`);
+      rebateTo = NULL_ADDRESS;
+    }
+
+    const swapData = ifaces.PPV2.encodeFunctionData('swap', [
+      _srcToken,
+      _destToken,
+      srcAmount,
+      MIN_CONVERSION_RATE,
+      recipient,
+      // this.augustusAddress,
+      rebateTo,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: this.config.wooPPV2Address,
+      transferSrcTokenBeforeSwap: this.config.wooPPV2Address,
+    };
+  }
+
   async updatePoolState(): Promise<void> {
     if (this._baseTokens === undefined || this.tokenByAddress === undefined) {
       await this.initializeTokensAndAddresses();

package/src/dex/wsteth/wsteth-e2e.test.ts

@@ -26,9 +26,10 @@ function testForNetwork(
     [
       SwapSide.SELL,
       [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
+        // ContractMethod.simpleSwap,
+        // ContractMethod.multiSwap,
+        // ContractMethod.megaSwap,
+        ContractMethod.swapExactAmountIn,
       ],
     ],
   ]);

package/src/dex/wsteth/wsteth.ts

@@ -8,6 +8,8 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
+  NumberAsString,
+  DexExchangeParam,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -241,6 +243,28 @@ export class WstETH extends SimpleExchange implements IDex<WstETHData> {
     }
   }
 
+  async getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: WstETHData,
+    side: SwapSide,
+  ): Promise<DexExchangeParam> {
+    const exchangeData = WstETH.wstETHIface.encodeFunctionData(
+      srcToken.toLowerCase() === this.config.stETHAddress ? 'wrap' : 'unwrap',
+      [srcAmount],
+    );
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData,
+      targetExchange: this.config.wstETHAddress,
+    };
+  }
+
   // Returns list of top pools based on liquidity. Max
   // limit number pools should be returned.
   async getTopPoolsForToken(

package/src/dex/zerox/config.ts

@@ -0,0 +1,31 @@
+import { Network } from '../../constants';
+
+export const ZRX_EXCHANGE: Record<number, Record<number, string>> = {
+  [Network.MAINNET]: {
+    2: '0x080bf510fcbf18b91105470639e9561022937712',
+    3: '0x61935CbDd02287B511119DDb11Aeb42F1593b7Ef',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.BSC]: {
+    2: '0x3F93C3D9304a70c9104642AB8cD37b1E2a7c203A',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.POLYGON]: {
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+};
+
+export const ZRX_EXCHANGE_ERC20PROXY: Record<number, Record<number, string>> = {
+  [Network.MAINNET]: {
+    1: '0x95E6F48254609A6ee006F7D493c8e5fB97094ceF',
+    2: '0x95E6F48254609A6ee006F7D493c8e5fB97094ceF',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.BSC]: {
+    2: '0xCF21d4b7a265FF779accBA55Ace0F56C8cE6e379',
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+  [Network.POLYGON]: {
+    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
+  },
+};

package/src/dex/zerox/index.ts

@@ -14,32 +14,20 @@ import type { IDexTxBuilder } from '../idex';
 import type {
   AdapterExchangeParam,
   Address,
+  DexExchangeParam,
   NumberAsString,
   SimpleExchangeParam,
   TxInfo,
 } from '../../types';
-import type {
-  ZeroXSignedOrder,
-  ZeroXSignedOrderV2,
-  ZeroXSignedOrderV4,
+import {
+  ZeroXFunctions,
+  type ZeroXData,
+  type ZeroXParam,
+  type ZeroXSignedOrderV2,
+  type ZeroXSignedOrderV4,
 } from './types';
-import Web3 from 'web3';
 import { IDexHelper } from '../../dex-helper';
-
-const ZRX_EXCHANGE: any = {
-  1: {
-    2: '0x080bf510fcbf18b91105470639e9561022937712',
-    3: '0x61935CbDd02287B511119DDb11Aeb42F1593b7Ef',
-    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
-  },
-  56: {
-    2: '0x3F93C3D9304a70c9104642AB8cD37b1E2a7c203A',
-    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
-  },
-  137: {
-    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
-  },
-};
+import { ZRX_EXCHANGE, ZRX_EXCHANGE_ERC20PROXY } from './config';
 
 const ZRX_ABI: any = {
   2: ZRX_V2_ABI,
@@ -47,53 +35,6 @@ const ZRX_ABI: any = {
   4: ZRX_V4_ABI,
 };
 
-const ZRX_EXCHANGE_ERC20PROXY: any = {
-  1: {
-    1: '0x95E6F48254609A6ee006F7D493c8e5fB97094ceF',
-    2: '0x95E6F48254609A6ee006F7D493c8e5fB97094ceF',
-    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
-  },
-  56: {
-    2: '0xCF21d4b7a265FF779accBA55Ace0F56C8cE6e379',
-    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
-  },
-  137: {
-    4: '0xdef1c0ded9bec7f1a1670819833240f027b25eff',
-  },
-};
-
-enum ZeroXFunctions {
-  swapOnZeroXv2 = 'swapOnZeroXv2',
-  swapOnZeroXv4 = 'swapOnZeroXv4',
-  swapOnZeroXv2WithPermit = 'swapOnZeroXv2WithPermit',
-  swapOnZeroXv4WithPermit = 'swapOnZeroXv4WithPermit',
-}
-
-type ZeroXData = {
-  version: number;
-  order: ZeroXSignedOrder;
-};
-
-type SwapOnZeroXParam = [
-  srcToken: Address,
-  destToken: Address,
-  srcAmount: NumberAsString,
-  destAmount: NumberAsString,
-  exchange: Address,
-  payload: string,
-];
-type SwapOnZeroXWithPermitParam = [
-  srcToken: Address,
-  destToken: Address,
-  srcAmount: NumberAsString,
-  destAmount: NumberAsString,
-  exchange: Address,
-  payload: string,
-  permit: string,
-];
-
-type ZeroXParam = SwapOnZeroXParam | SwapOnZeroXWithPermitParam;
-
 export class ZeroX
   extends SimpleExchange
   implements IDexTxBuilder<ZeroXData, ZeroXParam>
@@ -264,6 +205,61 @@ export class ZeroX
     );
   }
 
+  getDexParam(
+    _srcToken: Address,
+    _destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    _recipient: Address,
+    data: ZeroXData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.BUY) {
+      // Adjust the srcAmount according to the exact order price (rounding up)
+      if (data.version === 4) {
+        const order = data.order as ZeroXSignedOrderV4;
+        if (BigInt(destAmount) > BigInt(order.makerAmount)) {
+          throw new Error(
+            `ZeroX destAmount ${destAmount} > makerAmount ${order.makerAmount}`,
+          );
+        }
+        const calc =
+          (BigInt(destAmount) * BigInt(order.takerAmount) +
+            BigInt(order.makerAmount) -
+            1n) /
+          BigInt(order.makerAmount);
+        if (calc > BigInt(srcAmount)) {
+          throw new Error(`ZeroX calc ${calc} > srcAmount ${srcAmount}`);
+        }
+        srcAmount = calc.toString();
+      } else {
+        const order = data.order as ZeroXSignedOrderV2;
+        if (BigInt(destAmount) > BigInt(order.makerAssetAmount)) {
+          throw new Error(
+            `ZeroX destAmount ${destAmount} > makerAmount ${order.makerAssetAmount}`,
+          );
+        }
+        const calc =
+          (BigInt(destAmount) * BigInt(order.takerAssetAmount) +
+            BigInt(order.makerAssetAmount) -
+            1n) /
+          BigInt(order.makerAssetAmount);
+        if (calc > BigInt(srcAmount)) {
+          throw new Error(`ZeroX calc ${calc} > srcAmount ${srcAmount}`);
+        }
+        srcAmount = calc.toString();
+      }
+    }
+    const swapData = this.buildSimpleSwapData(data, srcAmount);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      exchangeData: swapData,
+      targetExchange: this.getExchange(data),
+    };
+  }
+
   getDirectParam(
     srcToken: Address,
     destToken: Address,

package/src/dex/zerox/types.ts

@@ -1,3 +1,4 @@
+import { Address } from '@paraswap/sdk';
 import { NumberAsString } from '../../types';
 
 export enum OrderStatus {
@@ -46,3 +47,36 @@ export interface ZeroXSignedOrderV4 {
 }
 
 export type ZeroXSignedOrder = ZeroXSignedOrderV2 | ZeroXSignedOrderV4;
+
+export enum ZeroXFunctions {
+  swapOnZeroXv2 = 'swapOnZeroXv2',
+  swapOnZeroXv4 = 'swapOnZeroXv4',
+  swapOnZeroXv2WithPermit = 'swapOnZeroXv2WithPermit',
+  swapOnZeroXv4WithPermit = 'swapOnZeroXv4WithPermit',
+}
+
+export type ZeroXData = {
+  version: number;
+  order: ZeroXSignedOrder;
+};
+
+export type SwapOnZeroXParam = [
+  srcToken: Address,
+  destToken: Address,
+  srcAmount: NumberAsString,
+  destAmount: NumberAsString,
+  exchange: Address,
+  payload: string,
+];
+
+export type SwapOnZeroXWithPermitParam = [
+  srcToken: Address,
+  destToken: Address,
+  srcAmount: NumberAsString,
+  destAmount: NumberAsString,
+  exchange: Address,
+  payload: string,
+  permit: string,
+];
+
+export type ZeroXParam = SwapOnZeroXParam | SwapOnZeroXWithPermitParam;

package/src/dex/zerox/zerox-e2e.test.ts

@@ -0,0 +1,110 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+
+import { ContractMethod, Network, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+const dexKey = 'zerox';
+
+const testForNetwork = (
+  network: Network,
+  swapMap: Map<SwapSide, ContractMethod[]>,
+) => {
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const nativeSymbol = NativeTokenSymbols[network];
+
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+
+  const tokensToTest = [
+    [
+      {
+        symbol: 'USDC',
+        amount: (10 ** 8).toString(),
+      },
+      {
+        symbol: 'USDT',
+        amount: (10 ** 8).toString(),
+      },
+    ],
+    [
+      {
+        symbol: 'USDT',
+        amount: (10 ** 8).toString(),
+      },
+      {
+        symbol: 'DAI',
+        amount: (10 ** 8).toString(),
+      },
+    ],
+  ];
+
+  swapMap.forEach((contractMethods, side) =>
+    contractMethods.forEach((contractMethod: string) => {
+      tokensToTest.forEach(pair => {
+        describe(`${contractMethod}`, () => {
+          it(`${pair[0].symbol} -> ${pair[1].symbol}`, async () => {
+            await testE2E(
+              tokens[pair[0].symbol],
+              tokens[pair[1].symbol],
+              holders[pair[0].symbol],
+              side === SwapSide.SELL ? pair[0].amount : pair[1].amount,
+              side,
+              dexKey,
+              contractMethod as any,
+              network,
+              provider,
+            );
+          });
+
+          it(`${nativeSymbol} -> ${pair[0].symbol}`, async () => {
+            await testE2E(
+              tokens[nativeSymbol],
+              tokens[pair[0].symbol],
+              holders[nativeSymbol],
+              side === SwapSide.SELL ? '1000000000000000000' : pair[0].amount,
+              side,
+              dexKey,
+              contractMethod as any,
+              network,
+              provider,
+            );
+          });
+        });
+      });
+    }),
+  );
+};
+
+// Ensure you have the E2E_ENDPOINT_URL env variable set.
+
+describe('ZeroX v2.1 E2E', () => {
+  describe('Mainnet V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    ]);
+
+    testForNetwork(Network.MAINNET, swapMap);
+  });
+
+  describe('Polygon V6', () => {
+    const swapMap = new Map<SwapSide, ContractMethod[]>([
+      [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+      [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+    ]);
+
+    testForNetwork(Network.POLYGON, swapMap);
+  });
+});

package/src/dex-helper/dummy-dex-helper.ts

@@ -19,12 +19,14 @@ import { MultiWrapper } from '../lib/multi-wrapper';
 import { Response, RequestConfig } from './irequest-wrapper';
 import { BlockHeader } from 'web3-eth';
 import { PromiseScheduler } from '../lib/promise-scheduler';
+import { AugustusApprovals } from '../dex/augustus-approvals';
 
 const logger = getLogger('DummyDexHelper');
 
 // This is a dummy cache for testing purposes
 class DummyCache implements ICache {
   private storage: Record<string, string> = {};
+  private hashStorage: Record<string, Record<string, string>> = {};
 
   private setMap: Record<string, Set<string>> = {};
 
@@ -137,11 +139,29 @@ class DummyCache implements ICache {
   }
 
   async hset(mapKey: string, key: string, value: string): Promise<void> {
+    if (!this.hashStorage[mapKey]) this.hashStorage[mapKey] = {};
+    this.hashStorage[mapKey][key] = value;
     return;
   }
 
   async hget(mapKey: string, key: string): Promise<string | null> {
-    return null;
+    return this.hashStorage[mapKey][key];
+  }
+
+  async hmget(mapKey: string, keys: string[]): Promise<(string | null)[]> {
+    return keys.map(key => this.hashStorage?.[mapKey]?.[key] ?? null);
+  }
+
+  // even though native hmset is deprecated in redis, use it to prevent changing implemented hset
+  async hmset(mapKey: string, mappings: Record<string, string>): Promise<void> {
+    if (!this.hashStorage[mapKey]) this.hashStorage[mapKey] = {};
+
+    this.hashStorage[mapKey] = {
+      ...this.hashStorage[mapKey],
+      ...mappings,
+    };
+
+    return;
   }
 
   async hgetAll(mapKey: string): Promise<Record<string, string>> {
@@ -245,6 +265,7 @@ export class DummyDexHelper implements IDexHelper {
   provider: Provider;
   multiContract: Contract;
   multiWrapper: MultiWrapper;
+  augustusApprovals: AugustusApprovals;
   promiseScheduler: PromiseScheduler;
   blockManager: IBlockManager;
   getLogger: LoggerConstructor;
@@ -285,6 +306,12 @@ export class DummyDexHelper implements IDexHelper {
       5,
       this.getLogger(`PromiseScheduler-${network}`),
     );
+
+    this.augustusApprovals = new AugustusApprovals(
+      this.config,
+      this.cache,
+      this.multiWrapper,
+    );
   }
 
   replaceProviderWithRPC(rpcUrl: string) {

package/src/dex-helper/icache.ts

@@ -58,6 +58,10 @@ export interface ICache {
 
   hget(mapKey: string, key: string): Promise<string | null>;
 
+  hmget(mapKey: string, keys: string[]): Promise<(string | null)[]>;
+
+  hmset(mapKey: string, mappings: Record<string, string>): Promise<void>;
+
   hgetAll(mapKey: string): Promise<Record<string, string>>;
 
   publish(channel: string, msg: string): Promise<void>;

package/src/dex-helper/idex-helper.ts

@@ -9,6 +9,7 @@ import { Token } from '../types';
 import { ConfigHelper } from '../config';
 import { MultiWrapper } from '../lib/multi-wrapper';
 import { PromiseScheduler } from '../lib/promise-scheduler';
+import { AugustusApprovals } from '../dex/augustus-approvals';
 
 export interface IDexHelper {
   config: ConfigHelper;
@@ -16,6 +17,7 @@ export interface IDexHelper {
   httpRequest: IRequestWrapper;
   multiContract: Contract;
   multiWrapper: MultiWrapper;
+  augustusApprovals: AugustusApprovals;
   promiseScheduler: PromiseScheduler;
   provider: Provider;
   web3Provider: Web3;